Technology
Cutting-edge graphics technology,
as a dedicated engine for 2D/3D editors.
Conventional web and native app frameworks couldn't fully harness GPU performance, or hit their limits building a unique experience where 2D, 3D, and UI are deeply fused. To achieve true cross-platform reach and zero-overhead processing by handling 2D / 3D / UI on a single foundation, Strura redesigned everything from the graphics base (wgpu) to the compute engine from scratch. It pushes each platform's hardware to its limit and delivers overwhelming performance that never interrupts the thinking of the person drawing space.
Full-Scratch GUI
An in-house GUI framework
Panels, drawing, 3D and nodes update in the same frame of one rendering foundation.
General-purpose GUI frameworks are designed for forms and 2D screens. But an editor with BIM-grade 2D and 3D viewports needs space, the graph editor, in-space manipulation, and UI working together on one screen without overhead.
Rather than bending the design to an existing framework's constraints, we design the UI runtime itself so 2D / 3D / UI can be handled on the same graphics foundation without distinction. That is Strura's approach.
- RustCore implementation language balancing safety and performance
- winitCross-platform window management and event handling
- wgpuAn abstraction layer that draws the most out of each OS's GPU (Windows / macOS / Web)
- Custom RendererAn in-house rendering engine unifying 2D / 3D / UI in a single pipeline
- Custom GUIA GUI framework wired straight to editor data, with no transfer loss
Signal-Based Architecture
Signal-driven diff updates
With its own rendering pipeline, Strura redesigned the very concept of the browser DOM. It eliminates the "double management" of a virtual DOM and a render cycle like React's, adopting a signal-based architecture in the family of SolidJS. State changes reflect directly into our own render nodes (a custom DOM), so responsiveness holds even on huge models.
Virtual DOM — compare the whole tree
Signal — update only what changed
A state change reaches the render node directly.
Declarative UI
A declarative design that describes UI from state. The UI follows the complex state changes of an editor automatically and accurately.
No double cycle (signal-driven)
Resolves the "double rendering cycle" of virtual-DOM diffing plus actual drawing. From a signal's change notification, it rewrites only the custom render nodes that need updating, pinpoint and direct.
Minimal GPU rendering
Instead of recomputing and redrawing the whole screen every frame, only changed elements are sent straight to the GPU. Rendering load and overhead are cut to the extreme.
CAD Kernel
An in-house CAD kernel
"NURBS" for smooth curves, "Implicit" for complex booleans and simulation, and "B-Rep" to hold the final shape suited to BIM. Strura uses these representations optimally, and to handle architectural semantics and geometry as one, it develops its own CAD kernel from scratch.
Curves and surfaces defined by control points
Each representation where it fits, semantics and geometry in one graph.
Problems with existing kernels
- Complex boolean processing (set operations) is prone to compute errors and breakage
- Modeling methods are fixed, making free expression and BIM data hard to reconcile
- Internals become black boxes, impossible to optimize for real-time edit propagation
- BIM semantics and geometry data are separated, bloating data size and processing
Strura's approach
- NURBSMathematical representation of curves and surfaces
- ImplicitFast, breakage-free processing of complex booleans and simulation
- B-RepBoundary representation outputs a clear topology structure easy to handle as BIM data
- Node GraphUnifies NURBS / Implicit / B-Rep and architectural semantics in a single graph
Photorealistic Rendering
A built-in GPU path tracer
The building model you designed renders photorealistically in the built-in GPU path tracer, with no export to another tool. Materials, sun and sky, and lights are attributes the building data already holds. Design and visualization connect inside one runtime.
Rendering never blocks editing. It converges straight from the same building data.
A physically based GPU path tracer
An in-house compute kernel written in WGSL. Physically based materials, a sun-and-atmosphere sky, HDRI, depth of field and denoising — all implemented from scratch.
The scene comes straight from the building data
Materials and lights are held as attributes of the building elements, and the renderer builds its scene directly from the same node graph. No export, no conversion.
It never stops the design
Rendering doesn't block editing. Watch the image converge, and keep modeling in the meantime.
Single Runtime & Parallel Execution
One runtime,
geometry computed in the background
Rather than linking UI, 3D, state management, building data, and the CAD kernel across separate frameworks, everything is processed in a single event loop. That eliminates wasteful data hand-offs between threads and complex state-sync cost. On top of that, only heavy geometry computation and draw-command generation are distributed in parallel to the background. The result is an architecture that keeps frame rates high and interaction smooth even on huge models.
Heavy work goes to the background. The frame never stops.
Architecture Comparison
Two approaches compared
A general-purpose GUI made for forms and 2D screens (DOM / native toolkit)
A GUI foundation designed for 2D/3D editors
Separate layers bridged together (DOM to a WebGL canvas, toolkit to a 3D viewport)
One scene graph, updated together in one frame
GPU for the viewport only, UI drawn on the CPU
The whole screen drawn by wgpu (Metal / DX12 / Vulkan / WebGPU)
Between the UI, the WASM kernel, the render engine and workers, the app converts types and designs the ownership and synchronisation of shared memory itself
One memory, one type system, one threading model: background threads are talked to directly. With no conversion and no sync protocol to design, it is fast and maintainable
Export to a separate tool or service
Built-in GPU path tracer, straight from the same building data
Browser only, or one operating system only
Mac, Windows and Web from one codebase
The ease of a web app and the performance of a native app. Strura adopts a new architecture that addresses both.
Cross-Platform & Sync
Native and Web,
one protocol
Serious design work with huge building data shows its true worth on desktop native, free of memory or GPU limits. In the browser, WASM / WebGPU enable a comfortable, well-optimized experience. Across Mac, Windows, and Web, real-time sync and collaboration run on the same protocol.
Synced in real time from any environment, over one protocol
Native First, High-Performance Web
Centered on desktop native without memory or graphics limits, it delivers a lag-free design experience even on huge models. On the web it drives WASM / WebGPU to draw out the best response under browser constraints.
Realtime Protocol Sync
Communication between apps and browsers is designed on a shared protocol. Even between Mac/Windows desktop apps and a web browser, one building data can be edited and shared in real time, simultaneously.
Optimized Choice
Settle in on desktop for heavy geometry, large model building and GPU rendering. Share with clients, or check and lightly edit on site — all in an install-free web browser. The right tool for each situation.
Try it in your browser.
The Strura modeling demo runs right in your browser. There is nothing to install. The desktop build for macOS and Windows is licensed to the people helping us test.