step assembly support blog post, docs, update tags

Author: matas-bitbybit-dev

docs/blog/2026-01-21-release-v1-rc0.md

@@ -2,7 +2,7 @@
 slug: bitbybit-v1-release-candidate-0
 title: "Bitbybit v1.0.0 Release Candidate 0 - A New Foundation for 3D CAD on the Web"
 authors: [ubarevicius]
-tags: [bitbybit, cad, occt, release]
+tags: [bitbybit, cad, occt]
 description: "After nearly 100 releases in the 0.x.x range, version 1.0.0 Release Candidate 0 is now available. This milestone brings a completely rebuilt core on top of native OCCT, significant performance improvements, and exciting new features."
 ---
 

docs/blog/2026-02-04-step-assembly-support.mdx

@@ -0,0 +1,119 @@
+---
+slug: step-assembly-support-v1-rc1
+title: "STEP Assembly Support: Load, Parse, and Export Professional CAD Files"
+authors: [ubarevicius]
+tags: [occt, assembly, step, gltf, cad, freecad]
+description: "Bitbybit v1.0.0-rc.1 introduces STEP assembly support - load complex CAD files, parse part hierarchies, extract components, preserve colors, and export to GLTF or STEP formats."
+image: https://ik.imagekit.io/bitbybit/app/assets/blog/step-assembly-support/step-assembly-support-occt-bitbybit.webp
+---
+
+![Bitbybit STEP Assembly Support](https://ik.imagekit.io/bitbybit/app/assets/blog/step-assembly-support/step-assembly-support-occt-bitbybit.webp "Bitbybit STEP Assembly Support")
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+If you've ever tried to load, edit or create a complex STEP assembly in a web browser, you know how tricky it can be. STEP is the standard format engineers use to share CAD models, but browsers don't understand it natively. You usually need desktop software or a server to convert it.
+
+With **Bitbybit v1.0.0-rc.1**, that changes. You can now load STEP assemblies directly in the browser, explore their structure, extract individual parts, and export to web-friendly formats. Everything runs locally using Bitbybit OCCT WebAssembly.
+
+<!-- truncate -->
+
+## What Can You Do?
+
+You can load a STEP file and see its full assembly tree, just like you would in FreeCAD or SolidWorks. Each part has a label (something like `0:1:1:3`) that you can use to extract that specific piece.
+
+![FarmBot STEP Assembly of Soil Sensor in FreeCAD](https://ik.imagekit.io/bitbybit/app/assets/blog/step-assembly-support/freecad-step-assembly.webp "FarmBot STEP Assembly of Soil Sensor in FreeCAD")
+![FarmBot STEP Assembly of Soil Sensor in Bitbybit](https://ik.imagekit.io/bitbybit/app/assets/blog/step-assembly-support/farmbot-soil-sensor-step-assembly-in-bitbybit.webp "FarmBot STEP Assembly of Soil Sensor in Bitbybit")
+
+Colors are parsed too. Regular STEP exports lose color data, but we use OCCT's XCAF format to embed colors into the assembly structure. This also works if users export a colored model from Bitbybit and open it in FreeCAD or other CAD software.
+
+You can also convert assemblies to GLTF/GLB format for use in games, web viewers, or AR applications. And since everything happens in your browser, your files never leave your computer.
+
+![Simple Workflow to convert STEP to GLTF](https://ik.imagekit.io/bitbybit/app/assets/blog/step-assembly-support/step-to-gltf-in-bitbybit-rete-editor.webp "Simple Workflow to convert STEP to GLTF")
+
+## Parametric Scripts to STEP Assemblies
+
+This is where the workflow really shines. You can build parametric geometry in Bitbybit - using visual programming or TypeScript - and export it directly to STEP format with colors preserved. Change a parameter, re-run the script, and download a new STEP file ready for manufacturing or further CAD work.
+
+Imagine a product configurator where customers adjust dimensions, then download a professional CAD file they can send to a machine shop. Or a design tool that generates custom brackets based on user inputs. The geometry is created algorithmically, but the output is the same format that engineers use in SolidWorks or Fusion 360.
+
+Furthermore - part instances and colors are supported, so users of third party CAD applications will be able to load these optimized assets in efficient manner.
+
+![Create OCCT STEP Assembly in Bitbybit](https://ik.imagekit.io/bitbybit/app/assets/blog/step-assembly-support/create-occt-step-assembly-in-bitbybit.webp "Create OCCT STEP Assembly in Bitbybit")
+
+![Open Bitbybit OCCT STEP Assembly in FreeCAD](https://ik.imagekit.io/bitbybit/app/assets/blog/step-assembly-support/bitbybit-assembly-opened-in-freecad-with-structure.webp "Open Bitbybit OCCT STEP Assembly in FreeCAD")
+
+## Why Does This Matter?
+
+Real products aren't single shapes. A bicycle has wheels, a frame, handlebars. An electronic device has a case, buttons, internal components. Engineers design each part separately, then assemble them digitally.
+
+STEP files preserve this structure. When you load one, you get the full hierarchy of parts and sub-assemblies, along with names, colors, and positions. This is useful for building product configurators, design review tools, or documentation systems where you need to work with individual components.
+
+## The API
+
+There are two groups of methods. The **Manager** methods let you build and export assemblies: `createPart`, `createAssemblyNode`, `createInstanceNode`, `combineStructure`, `buildAssemblyDocument`, `exportDocumentToStep`, and `exportDocumentToGltf`.
+
+The **Query** methods let you inspect existing documents: `getDocumentParts`, `getAssemblyHierarchy`, `getShapeFromLabel`, `getLabelColor`, `getLabelTransform`, and `getLabelInfo`.
+
+![Create STEP Assemblies in Rete](https://ik.imagekit.io/bitbybit/app/assets/blog/step-assembly-support/occt-step-assembly-creation-components.webp "Create STEP Assemblies in Rete")
+
+## Visual Programming
+
+If you use Rete or Blockly, we've added components for all of this. The hierarchy preview is especially handy - it shows the assembly tree and lets you click on any item to see its label, which you can then use to extract that part.
+
+## Your Files Stay Private
+
+Everything runs in your browser. OCCT is compiled to WebAssembly, so parsing and exporting happens locally. Your files are never uploaded anywhere. This matters if you're working with proprietary designs.
+
+:::warning Memory Note
+Large assemblies need memory. The standard build supports up to 2GB. For complex models, use the 64-bit version (up to 16GB).
+:::
+
+## Tutorials
+
+We have step-by-step tutorials to get you started:
+
+- [Introduction to Assemblies](/learn/code/common/occt/assembly/intro) - the basics
+- [Convert STEP to GLTF](/learn/code/common/occt/assembly/step-to-gltf) - for web viewing
+- [Parse Assembly Structure](/learn/code/common/occt/assembly/assembly-structure) - explore parts
+- [Build and Export Assemblies](/learn/code/common/occt/assembly/create-assembly) - create from scratch
+- [Export Shapes with Color](/learn/code/common/occt/assembly/shape-to-step-with-color-assembly) - preserve colors
+
+Each one has examples in Rete, Blockly, and TypeScript.
+
+## Example: Load and Display a STEP Assembly
+
+Here's the simplest workflow - load a STEP file and display it in the browser:
+
+```typescript
+// Fetch the STEP file
+const stepData = await bitbybit.asset.fetchFile({
+    url: "https://learn.bitbybit.dev/files/3d/Soil-Sensor.stpZ"
+});
+
+// Convert to GLTF for display
+const glbData = await bitbybit.occt.io.convertStepToGltf({
+    stepData,
+    meshPrecision: 0.05
+});
+
+// Load into the 3D scene
+await bitbybit.babylon.io.loadGlbFromArrayBuffer({
+    glbData,
+    fileName: "model.glb"
+});
+```
+
+That's it - three function calls to go from a STEP file to 3D model in the browser.
+
+## What's Next?
+
+This is a release candidate. We're still adding features and improving coordinate system handling for different CAD conventions. If you find issues or have ideas, let us know on [Discord](https://discord.gg/GSe3VMe).
+
+## Credits
+
+The soil sensor model in our tutorials comes from [FarmBot](https://genesis.farm.bot/v1.5/Extras/cad.html), an open-source CNC farming robot. Their CAD files are public domain.
+
+---
+
+**Ready to try it?** Head to the [assembly tutorials](/learn/code/common/occt/assembly) and load your first STEP file.

docs/blog/tags.yml

@@ -1,64 +1,89 @@
 bitbybit:
   label: Bitbybit
   permalink: /bitbybit
-  description: Blog posts about Bitbybit
+  description: Platform updates, new features, and tutorials for the Bitbybit visual programming environment.
 
 cloud:
   label: Cloud
   permalink: /cloud
-  description: Blog posts about Cloud
+  description: Cloud, server-side services, and scalable 3D workflows.
 
 ai:
   label: AI
   permalink: /ai
-  description: Blog posts about Artificial Intelligence
+  description: Using AI assistants and machine learning with 3D modeling and CAD automation.
 
 cad:
   label: CAD
   permalink: /cad
-  description: Blog posts about Computer-Aided Design
+  description: Computer-Aided Design techniques, precision modeling, and engineering workflows.
 
 xr:
   label: XR
   permalink: /xr
-  description: Blog posts about Extended Reality
+  description: Extended Reality experiences combining AR, VR, and mixed reality with 3D content.
 
 vr:
   label: VR
   permalink: /vr
-  description: Blog posts about Virtual Reality
+  description: Virtual Reality applications for immersive 3D visualization and interaction.
 
 3d-bits:
   label: 3D Bits
   permalink: /3d-bits
-  description: Blog posts about 3D Bits app for Shopify and its use cases
+  description: Our Shopify app for embedding interactive 3D product configurators in online stores.
 
 shopify:
   label: Shopify
   permalink: /shopify
-  description: Blog posts about Shopify integrations via 3D Bits app
+  description: E-commerce integrations, product visualization, and 3D configurators for Shopify stores.
 
 case-study:
   label: Case Study
   permalink: /case-study
-  description: Case studies related to Bitbybit, 3D Bits and Shopify
+  description: Real-world examples of how businesses use Bitbybit and 3D Bits to solve problems.
 
 fitness-equipment:
   label: Fitness Equipment
   permalink: /fitness-equipment
-  description: Blog posts about fitness equipment industry and 3D visualization
+  description: 3D visualization and configuration solutions for gym and fitness equipment retailers.
 
 babylonjs:
   label: BabylonJS
   permalink: /babylonjs
-  description: Blog posts about Babylon.js 3D engine
+  description: Using the Babylon.js WebGL engine for real-time 3D graphics in the browser.
 
 threejs:
   label: ThreeJS
   permalink: /threejs
-  description: Blog posts about Three.js 3D library
+  description: Working with Three.js for lightweight 3D scenes and custom rendering pipelines.
 
 playcanvas:
   label: PlayCanvas
   permalink: /playcanvas
-  description: Blog posts about PlayCanvas 3D engine
+  description: PlayCanvas engine integration for game-like 3D experiences and interactive apps.
+
+occt:
+  label: OCCT
+  permalink: /occt
+  description: OpenCASCADE Technology - the open-source CAD kernel powering our geometry operations.
+
+assembly:
+  label: Assembly
+  permalink: /assembly
+  description: Working with multi-part CAD assemblies, hierarchies, and component structures.
+
+step:
+  label: STEP
+  permalink: /step
+  description: The ISO 10303 standard format for exchanging CAD data between different software.
+
+gltf:
+  label: GLTF
+  permalink: /gltf
+  description: The web-optimized 3D format for fast loading and rendering in browsers and apps.
+
+freecad:
+  label: FreeCAD
+  permalink: /freecad
+  description: Interoperability with FreeCAD, the popular open-source parametric CAD modeler.

docs/learn/code/common/occt/assembly/assembly-structure.mdx

@@ -82,7 +82,7 @@ This first example shows the basic workflow - loading a STEP file and extracting
 
 ## Parse more parts
 
-Once you understand the basics, you can extract multiple parts and style them independently. This is where things get exciting — you can create custom visualizations that highlight different components, use original colors from the CAD model, or apply your own color schemes.
+Once you understand the basics, you can extract multiple parts and style them independently. This is where things get exciting - you can create custom visualizations that highlight different components, use original colors from the CAD model, or apply your own color schemes.
 
 ### What's New in This Example?
 

docs/learn/code/common/occt/assembly/shape-to-step-with-color-assembly.mdx

@@ -18,61 +18,19 @@ import BitByBitRenderCanvas from '@site/src/components/BitByBitRenderCanvas';
   alt="OCCT category icon with a stylized logo representation" 
   title="OCCT category icon" />
 
-Standard STEP files store only geometry — no color information. To preserve colors, you need to use the assembly document structure. This was one of our most requested features, and it's finally available!
+When you export a shape to a regular STEP file, it loses all color information. The geometry is preserved, but open that file in FreeCAD or Fusion 360 and everything will be gray. That's just how STEP files work.
 
-## Why Colors Require Assemblies
+To keep colors, you need to wrap your shapes in an assembly document. This uses OCCT's XCAF format, which stores both geometry and appearance data. It's an extra step, but it means your colors will show up correctly in other CAD software.
 
-The XCAF (Extended CAD Application Framework) format used by OCCT can embed colors into assembly structures. By wrapping shapes in an assembly with color-assigned instances, you ensure colors transfer correctly to other CAD applications.
+## What This Example Does
 
-## What These Scripts Do
+The scripts below create a "pod shell" shape and export it as a colored STEP file. The geometry part uses several OCCT operations (points, wires, faces, mirrors, fillets) to build an interesting 3D solid. But the important part for this tutorial is at the end.
 
-The examples below demonstrate how to create a 3D shape in Bitbybit and export it as a STEP file with color information preserved. The exported file can then be opened in other CAD software like **FreeCAD**, **Fusion 360**, **SolidWorks**, or **Blender** with the assigned colors intact.
+Once we have the shape, we create an assembly structure around it. We define a part, put it inside an assembly, and assign it a white color. Then we export the whole thing to a `.stpZ` file (compressed STEP format). When you open that file in FreeCAD, the shape appears in white, just as we specified.
 
-### Script Breakdown
+## Try It Yourself
 
-**1. Scene Setup**
-- Configures directional lighting with shadows for realistic preview
-- Sets up a radial gradient background for visual appeal
-- Enables a hidden skybox to provide environment-based lighting
-
-**2. Geometry Creation**
-The scripts build a "pod shell" shape through several OCCT operations:
-- **Points & Wires**: Defines 5 key points and creates 4 polygon wires connecting them
-- **Faces**: Converts wires into planar faces
-- **Face with Hole**: Offsets a wire inward, fillets the corners, reverses it, and uses it to create a face with a cutout
-- **Shell Assembly**: Sews all faces together into a single shell
-- **Mirror**: Duplicates the shell across the Z-axis to create symmetry
-- **Fillet Edges**: Rounds the sharp edges where the two halves meet
-- **Thick Solid**: Adds wall thickness to convert the shell into a solid
-
-**3. Visual Rendering**
-- Creates a PBR (Physically Based Rendering) metallic material
-- Draws the solid with black edge outlines for better visibility
-
-**4. Assembly & Color Assignment**
-This is where the color preservation happens:
-- **Create Part**: Registers the shape as a named part (`pod-shell`)
-- **Create Assembly Node**: Creates a container for organizing parts (`Pod Assembly`)
-- **Create Instance Node**: Places the part in the assembly with a **white color** (RGB: 1, 1, 1)
-- **Combine Structure**: Merges parts and nodes into a complete assembly structure
-- **Build Document**: Generates the XCAF document that stores shapes with their colors
-
-**5. STEP Export**
-- Exports the assembly document to a `.stpZ` file (compressed STEP format)
-- The file includes the white color assigned to the instance
-- When opened in FreeCAD or other CAD software, the shape will display with the correct color
-
-### Why Use Assemblies for Color?
-
-Standard STEP files store only geometry—no color information. However, the XCAF (Extended CAD Application Framework) format used by OCCT can embed colors into assembly structures. By wrapping your shape in an assembly with color-assigned instances, you ensure that:
-
-- Colors transfer correctly to other CAD applications
-- You can assign different colors to different instances of the same part
-- The file structure is compatible with professional CAD software workflows
-
-### Try It Yourself
-
-Run the script, and a `pods.stpZ` file will download automatically. Open it in FreeCAD (File → Import), and you'll see the pod shape rendered in white—exactly as specified in the script.
+Run the script and a `pods.stpZ` file will download automatically. Open it in FreeCAD (File → Import) and you'll see the pod shape with its white color intact.
 
 <Tabs groupId="rete-shape-with-color-to-step-export">
 <TabItem value="rete-shape-with-color-to-step-export" label="Rete">

docs/learn/code/common/occt/assembly/step-to-gltf.mdx

@@ -18,15 +18,15 @@ import BitByBitRenderCanvas from '@site/src/components/BitByBitRenderCanvas';
   alt="OCCT category icon with a stylized logo representation" 
   title="OCCT category icon" />
 
-This tutorial shows you how to convert STEP files to web-optimized GLTF/GLB format — with all processing happening directly in your browser.
+This tutorial shows you how to convert STEP files to web-optimized GLTF/GLB format - with all processing happening directly in your browser.
 
 ## Why Export to GLTF?
 
 STEP files preserve precise CAD geometry but aren't optimized for web viewing. GLTF (the "JPEG of 3D") loads quickly in browsers and 3D engines while preserving colors and structure from the original file.
 
 ## Browser-Based Conversion
 
-All conversions happen **entirely in your browser** — no files are uploaded to any cloud servers. This has important implications:
+All conversions happen **entirely in your browser** - no files are uploaded to any cloud servers. This has important implications:
 
 ### Privacy Advantage
 Your CAD files never leave your computer. While you do need to use Bitbybit editors to run these conversions, your files are processed locally and are not uploaded to any cloud servers. This is critical for confidential engineering data, proprietary designs, or any situation where data privacy matters.