Skip to main content

buerli Introduction

Buerli is used for creating custom cloud CAD application. While customization is mainly done by developers, we also adress designers to iteractively create 3d parts and assemblies with our Buerligons systems. In fact, most teams building Buerli applications include both developers and designers. For building custom application you need a developer to embed Buerli in your web app and host a CAD server, but also someone who understands interactive and programmatic cad modeling.

CAD is a huge field and with Buerli we position us in some niches where Buerli offers great advantages to our customers. So we do not cover all aspects of complex 3d design instead, we are address with Buerli areas like automation of product configuration in the web.

The Buerli client comes together with a ClassCAD server backend. ClassCAD, our parametric history-based CAD system, performs the cad tasks and communicates results to the client. You must host the server by youself either locally or somewhere else (AWS, Azure,...). You can also compile the app bundled with a local server into an electron application and thereby enable offline usage. Technically speaking, command are communicated via websockets to the server and receive the reponse as structure and geometry protocol from server within a stateful architecture.

Central on the client side is our ClassCad API, which is the only api interface accepted by the ClassCAD server. Solid- and HistoryAPI are wrapper around this API to make programming easier. ClassCad API is used directly only from our react components, which are used in the CAD GUI Toolkit described later. A GetAPI() method will be available to access te differnt APIs.

Building custom CAD cloud applications has never ever been that easy!

From interactive design to headless programming.#

The CAD world is dominated by interactive design systems and there are a few programmable / scriptable languages that can perform CAD tasks. With Buerli you can build your custom interactive CAD system, use only programming with the headless API or combine both in your application. You can even bring your own Three.js Canvas from your web application and let Buerli generate geometry into it.

We are also convinced that CAD programming in a client server environment will open the doors for a huge group of programmers, to build up and reconfigure 3d parts and assemblies for all kinds of CAD related applications.

Buerli also combines interactive design and programming to take advantages of both worlds1. In design there are a several features where interaction is a must and can hardly be programmed; Edge-based operation like fillets and chamfers and, of course, 2d parametric sketches. The creation of complex surfaces by manipulation control points is also an area that cannot be covered by programnming; With Buerli you can code for example a selection feature, which breaks execution of the code to wait for a selection in the model by the developer. The api provides for type and number of selections etc. seen our examples on https://github.com/awv-informatik/buerli-examples

Using 2d parametric sketches within a progamming environment is possible by loading from a library of sketches created interactively. See our training for programmers for details on how to useSketches

Using code to create 3d models instead of using an interactive systems also provides certain advantages when it comes to CD/CI 2. We did not explore these areas yet.

CAD GUI toolkit#

Client applications can access the CAD functionality via API. For developers and companies interested in developing their own CAD GUIs we provide some react components that facilitate communication with the model. There are editor that include selectors of CAD elements, solids, instances in assemblies etc. etc. We did this by ourself and created the Buerligons end user CAD system. see https://github.com/awv-informatik/buerligons This github project is open source and you can see what is needed to build such a system.

enduser perspective#

A designer can use our buerligons application to interactively create parts and assemblies with the features. In the future, we will provide an electron app to download for an easy start.

programmer perspective#

As a programmer you can code 3d models from scratch or edit models that were created interactively in Buerligons. Parts or assemblies corresponds

application perspective#

All our applications have the following in common:

there is a cad server, where the parametric, history-based models are created. It includes a boundary representation modeler with the most usefull features to create 3d models including import of neutral step models and constraint based sketch solving.

they have a Canvas, where the 3d model is rendered and where you can interact with the model. Client side visualisation is done using react-three-fiber.

Configuration#

In 3d Product configuration the user can change some parameters in a "product specific" GUI Webapp and server calculates the new variant or configuration and returns it. Here is an example of our first swiss Buerli customer https://www.fms-technology.com/ configuring user customized force measurement assembly.

In the webapp everyone can build his custom configured variant and create necessary 3d step models or drawings on the fly. A enduser only specifies the parameters of the product and somewhere in the backend should be a CAD engine that generates this specific product.

Multivariant products differ in the configuration knowledge necessary to build these configuration. In the simplest case, there is a template of an assembly and the only thing needed is to change parameters of parts and assembly to build a new variant. Some calls to our API to set feature parameters and the possibility to recalculate the model is enough.

Dynamically adding different parts/ assemblies to an assembly under special conditions is more complex and requires some coding in javascript with history API.

There are also situations, where the product is really comlex and you need a configuration solver engine. In this case a pure Buerli solution is not possible. However we are also embedding Buerli into arbitrary configuration systems. In this situation all the configuration objects with their dynamic nature are managed within the knowledge based configurator, which could for example be constraint- or rule-based.

Please contact us, if you are a provider of such a configuration engine and want to embed Buerli.

Here is a link to a minimal "proof of concept" configuration repository, where you can simply change some parameters of model in the browser and the new model is recalculated on the server and shown in the Canvas https://github.com/awv-informatik/plugpoc Product configuration, assemble to order (ATO) or engineer to oder (ETO) is possible within Buerli applications. We are convinced that a configuration system belongs into a PLM system. The PLM is the system, where you store and maintain all parts and assemblies and the knowledge how they are configured. So put a configuration engine into a PLM system and add Buerli as a CAD engine to obtain

data storage perspective#

We can handle streams and files and it is basically up to the developer, where the application keeps its data. For design systems

  1. Hanno Braun called this the hybrid approach in https://hanno.braun-odw.eu/notes/code-cad-advantages/↩
  2. https://kittycad.io/blog/introducing-kittycad↩