A desktop application for viewing, measuring, editing and converting laser scans and other point clouds, and for turning them into section drawings, meshes and the flat faces of a building. It runs on Windows, Linux and macOS, is written in Rust and needs no browser or web view.
Browser edition: there is no supported browser or Frappe edition. The frozen classic/ 0.3.0 prototype is retained for reference only; it is not the current application and cannot handle the same large scans. To reproduce that historical prototype, run cd classic && npm ci && npm run build; the output is classic/dist/. Releases and supported builds come from the native Rust workspace in native/. The Classic deployment workflow has been retired so new native releases cannot be mistaken for web updates.
A generated scene, building.laz from the demo scene generator, in the English interface and the theme Light: a section box around the house, and the plan Ground floor, the section Section A and the saved view Front garden as tabs above the scene. It was taken with the development build after 0.9.5, which still reads v0.9.5 in the middle of its status bar. See the Display panel beneath the view cube as well, with the points coloured by class.
Watch the feature video — the generated house and rooms in the English interface and the theme Light: colour modes and detail, point selection, measuring, the section box, meshing, a 2D plan and section with straight CAD lines, a station photo in its own tab and beside the 3D model, the folding ribbon and the File view.
- Download and install
- The first five minutes
- What you can do
- File formats
- Measured speed and limits
- Automation
- Build from source
- Repository layout
- Licences
- Contributing
The user guide describes every tool in detail; an illustrated Dutch wiki manual covers the main workflows (source). CHANGELOG.md lists what changed in each release.
The files are on the releases page. In the names below VERSION is the number of the release: the year, the week of the year and a sequence number, for example open-pointcloud-studio_2026.44.0_x64-setup.exe.
| System | File | What it is |
|---|---|---|
| Windows 10 and 11, x64 | open-pointcloud-studio_VERSION_x64-setup.exe |
Installer |
open-pointcloud-studio_VERSION_windows-x64.zip |
The application with Open CAD Studio and the licence texts, without an installer | |
| macOS 11 and later, Apple and Intel processors | open-pointcloud-studio_VERSION_macos-universal.dmg |
Disk image with the application |
open-pointcloud-studio_VERSION_macos-universal.tar.gz |
The bare binaries and the licence texts | |
| Linux x86-64 | open-pointcloud-studio_VERSION_amd64.deb |
Package for Debian, Ubuntu and their relatives |
open-pointcloud-studio_VERSION_amd64.AppImage |
One file that runs on any distribution | |
open-pointcloud-studio_VERSION_linux-amd64.tar.gz |
The bare binaries and the licence texts | |
| Linux 64-bit ARM (experimental) | open-pointcloud-studio_VERSION_arm64.deb, _arm64.AppImage, _linux-arm64.tar.gz |
The same three kinds of file as for x86-64. Experimental: built and tested only on build machines with software rendering, not yet on real ARM boards or laptops |
| For programs of your own: Windows x64, macOS 11 and later, Linux x86-64 and 64-bit ARM | open-pointcloud-studio-sdk_VERSION_windows-x64-dll.zip, _macos-universal-dylib.tar.gz, _linux-amd64-so.tar.gz, _linux-arm64-so.tar.gz |
The point-cloud core as a C library, with its header, an example and the notices of the crates it is built from; see C library |
| Every system | SHA256SUMS |
The checksums of all the files above in one list; see Checking a download |
Every package also carries Open CAD Studio, the open-source CAD application, which shows exported DXF and DWG drawings; it does not have to be installed separately. The release page also holds open-cad-studio-source_SHORT.tar.gz, the source it was built from, and open-cad-studio-vendor_SHORT.tar.gz, the crates it was built with from git repositories.
Every file has a .sha256 file beside it, except SHA256SUMS itself and OpenPGP signatures; see Checking a download. Once a release is public, its page also gets open-pointcloud-studio_VERSION_verification.md: the record of the checks that the release workflow ran on the published files, with its .sha256. The cloud API is not a file of the release page but a container image; see Cloud API.
Run the installer. The release notes of each release say whether its Windows files carry a code signature. When they do not, Windows may warn about an unknown publisher ("Windows protected your PC") when you start the installer: choose More info and then Run anyway.
The installer asks for a language (English or Dutch) and installs for the current user without administrator rights, or for all users when you choose that in its first dialog. It adds a Start menu entry, a desktop icon if you tick that, and an uninstaller. It lists the application under "Open with" for E57, LAS, LAZ, PLY, PCD, PTX, PTS and XYZ files and scan project files (.rcp), without changing which program opens them by default.
The zip holds the same application: unpack it anywhere and start open-pointcloud-studio.exe in the folder it unpacks to. Without a code signature the same warning can appear the first time you start that file.
Open the disk image and drag Open Pointcloud Studio onto the Applications folder. The application is one file for Apple and Intel processors. It is offered under "Open With" for E57, LAS, LAZ, PLY, PCD, PTX and PTS files and scan project files (.rcp), without changing which program opens them by default.
The v0.9.5 macOS package is signed ad hoc and not notarised, so macOS may refuse its first start. Later release notes state whether their app and disk image are Developer ID signed and notarized; when they are, open the app normally. For an ad hoc release, allow it once:
- macOS 15 and later: start the application, close the message, open System Settings > Privacy & Security, scroll to Security, choose Open Anyway and confirm.
- macOS 11 to 14: Control-click the application, choose Open and confirm.
- Either version, from Terminal:
xattr -dr com.apple.quarantine "/Applications/Open Pointcloud Studio.app"
The disk image carries the same note as First start.txt. The .tar.gz holds the binary and Open CAD Studio without the application bundle, and the licence texts, for use from a terminal.
Linux needs a C library of version 2.35 or newer and the C++ runtime of GCC 12 or newer (libstdc++.so.6 with GLIBCXX_3.4.30, which Open CAD Studio uses): Ubuntu 22.04, Debian 12, Fedora 36 or later have both. It also needs X11 or Wayland, and a Vulkan driver or OpenGL ES 3 through EGL. File dialogs use the desktop portal, or zenity where there is none.
The .deb installs the application as /usr/bin/open-pointcloud-studio with a menu entry, its icon and the libraries it needs, puts Open CAD Studio in /usr/lib/open-pointcloud-studio, and offers the application for E57, LAS, LAZ, PLY, PCD, PTX and PTS files and scan project files:
sudo apt install ./open-pointcloud-studio_2026.44.0_amd64.debThe AppImage needs no installation. Make it executable once and start it:
chmod +x open-pointcloud-studio_2026.44.0_amd64.AppImage
./open-pointcloud-studio_2026.44.0_amd64.AppImageIt mounts itself through FUSE (fusermount3 or fusermount). Without FUSE, start it with --appimage-extract-and-run after the file name.
The .tar.gz holds the binary, Open CAD Studio beside it and the licence texts. It unpacks into a folder of its own name; run ./open-pointcloud-studio in that folder.
A .sha256 file holds the SHA-256 checksum of the file it is named after. With both in the same folder:
sha256sum -c open-pointcloud-studio_2026.44.0_amd64.deb.sha256 # Linux
shasum -a 256 -c open-pointcloud-studio_2026.44.0_macos-universal.dmg.sha256 # macOSGet-FileHash open-pointcloud-studio_2026.44.0_x64-setup.exe -Algorithm SHA256 # Windows
Get-Content open-pointcloud-studio_2026.44.0_x64-setup.exe.sha256On Linux and macOS the command answers OK. On Windows, compare the two outputs: the hash must be the same, apart from upper and lower case.
SHA256SUMS holds the checksums of all packages and archives of the release. In a folder with the files you downloaded beside it, this checks each of them and skips the others:
sha256sum --ignore-missing -c SHA256SUMSThe Linux packages and the Linux archives of the C library also carry a build attestation, kept by GitHub. With the GitHub CLI, signed in with gh auth login, this checks that the release workflow of this repository attested the file and that it has not been changed since; the output names the tag the workflow ran for:
gh attestation verify FILE --repo OpenAEC-Foundation/open-pointcloud-studio --signer-workflow OpenAEC-Foundation/open-pointcloud-studio/.github/workflows/release.ymlOpenPGP signatures of SHA256SUMS and of the AppImages follow once the organisation has its key; until then the release notes name none. docs/ecosystem.md lists the signature of every file and the command that checks it.
Start the application from the Start menu, the Applications folder or the menu of your desktop.
From a terminal it takes the files to open as arguments. Only the .deb puts the executable on the search path; with the others, write its path in place of open-pointcloud-studio in the commands of this page:
| Installed from | Executable |
|---|---|
| Windows installer, current user | %LOCALAPPDATA%\Programs\Open Pointcloud Studio\open-pointcloud-studio.exe, unless you chose another folder |
| Windows installer, all users | C:\Program Files\Open Pointcloud Studio\open-pointcloud-studio.exe, unless you chose another folder |
| macOS disk image | /Applications/Open Pointcloud Studio.app/Contents/MacOS/open-pointcloud-studio |
.deb |
open-pointcloud-studio (installed as /usr/bin/open-pointcloud-studio) |
| AppImage | The AppImage file itself |
zip or .tar.gz |
open-pointcloud-studio (.exe on Windows) in the unpacked folder open-pointcloud-studio_VERSION_... |
open-pointcloud-studio scan.laz
open-pointcloud-studio /path/to/scan-folder
open-pointcloud-studio project.rcp
open-pointcloud-studio --helpThe native Rust window has a title strip, one compact ribbon tab, Home (Start), above the 3D scene, a strip of document tabs under the ribbon, a Project Browser at the left and Properties at the right. Home holds the common file, navigation, selection, section box, surface, drawing, measuring, annotation, index and export tools; camera, colour and point-detail controls are under Display (Weergave) beneath the view cube. Groups fold into dropdowns when the window narrows. File (Bestand), the tab before Home, covers the ribbon and the scene with a menu of direct file and export actions, All export options… (Alle exportopties…), the open scans with the export settings, an Extensions page and About.
The interface follows the language of the system, English or Dutch; Settings > General (Instellingen > Algemeen) changes it. This page uses the English names and, in the steps below, gives the Dutch name in brackets where it differs.
-
Open a scan. Drop a file, a folder of scans or a scan project file (
.rcp) on the window. Or choose File > Import point cloud (Bestand > Puntenwolk importeren) or Open scan folder (Scanmap openen), or Open (Openen) in the FILE group of Home. Without a scan of your own, take a public one: the table of data sets in native/TEST_DATA.md links public point clouds, from a room scan of 0.6 MB (PCD) to tiles of several hundred megabytes of the Dutch height model AHN6 (LAZ). While a file is read or indexed, a strip above the scene shows how far it is, with a button to cancel.With several scans open, one of them is the active scan: its row in the project panel has a coloured outline, and a click on a row makes that scan the active one. The section box and Box select (Vak selecteren) act on every visible scan. The tools that pick a point (measuring, notes and lines, and Pick point, Punt kiezen) and the exports of step 7 use the active scan only.
-
Look around. Drag with the middle button while Shift is held to orbit (or with the left button while Alt is held), with the middle or right button to pan, and turn the wheel to zoom at the pointer. The left button selects: a click picks a point, a drag draws a selection rectangle. Double-click a point to orbit about that point.
For Zoom all (Alles tonen) goes back to the isometric overview of the whole model. The cube in the corner turns the view to a face or a corner. -
Choose how points are shown. Under Display (Weergave) beneath the view cube, pick RGB, Elevation (Hoogte), Intensity (Intensiteit) or Class (Klasse), and set Point size (Puntgrootte) and Points in view (Punten in beeld): the most points drawn at once. More points in view show more detail and ask more of the graphics card.
-
Cut a floor plan. Switch on Section box (Snedebox). A box appears around the whole model, with a round handle in the middle of each face. Drag the handle of the top face down to about a metre above a floor, so that the box cuts through the walls. Then click the top face of the view cube (BOVEN) to look straight down. Seen from straight above, dragging the top handle has little or no effect; to change the height there, use the Z max slider under Section box in the Properties panel, or type the height as Z Max and choose Apply XYZ limits (XYZ-grenzen toepassen).
-
Measure. Choose Distance (Afstand) in the MEASURE group (METEN) and click two points; the distance ends at the second. The length appears in the scene; the Properties panel also lists the horizontal length and the height difference.
-
Save the view. Choose Save view (View opslaan) under VIEWS in the Project Browser. The view is listed there under 3D views, after the 3D model; a click on its name brings back the camera, the section box while it was on, and the colour mode. Create 2D plan / elevation / section… (2D-plattegrond / aanzicht / doorsnede maken…), an icon on the band of VIEWS, makes a plan, an elevation or a section, which VIEWS then lists under its kind and which opens as a tab beside 3D model (3D-model) in the document strip above the scene; click a tab to switch, × to close it. Click the outline of its crop region (bijsnijgebied) to select it, then drag its handles or type its figures in Properties to change what it shows; the drawing is made again from the points it already read. Copy it with Duplicate (Dupliceren) beside ×, and type R and then O to turn the crop region of a plan along the walls. With Note (Notitie) under Annotations in Properties, or Add note (Notitie toevoegen) in the ANNOTATION group, click a point, type a text and press Enter. File → All export options… → Views as BCF… (Bestand → Alle exportopties… → Views als BCF…) writes the views of the scan, with their notes and a picture each, as one
.bcffile: the BIM Collaboration Format, an open format for passing viewpoints and remarks on a building between programs. -
Export what you cut. Choose File and then All export options… (Alle exportopties…), pick a Format (Formaat) under POINT CLOUD (PUNTENWOLK), then choose Section box… (Snedebox…); Export section box… (Snedebox exporteren…) in the File menu does the same, in the format chosen on that page. The file holds every point of the active scan inside the box, not only the points on screen. With several scans open, make each one active in turn and export it, or first join LAS and LAZ scans with Merge visible LAS/LAZ scans… (Zichtbare LAS/LAZ-scans samenvoegen…).
Three tools take the section box further. 2D section (2D snede) in the DRAWING group (TEKENING) opens the Section drawing tool, which saves the cut of step 4 as a 2D drawing in DXF or DWG, from all visible scans. With the box around one room, Mesh in the SURFACE group (OPPERVLAK) opens Mesh Pointcloud (Puntenwolk meshen), which makes a Closed mesh (Gesloten mesh) of that room, or finds its Flat faces (Vlakken): its floor, ceiling, walls and round columns with their areas. Closed (Gesloten) and Faces (Vlakken) beside Mesh open it on those methods.
The source files are never changed: deleting, thinning, moving and scaling apply to the open view and to what you export.
The user guide has the detail of every heading below.
- Point clouds in LAS, LAZ, E57, PLY, PCD, PTX, PTS and text formats, meshes in OBJ, PLY, OFF and STL, and the points and faces of an ASCII DXF; see File formats.
- A whole scan project at once: every supported file in a folder, or the scans that a scan project file (
.rcp) lists and that lie beside it. - Several files together, each as a layer that can be hidden, shown or closed; mark several layers with Shift-click and Ctrl-click to hide, show or close them together.
- Large files stay usable while they open: LAS and LAZ open from their header, an E57 file of 512 MiB or more shows a sample spread through the file within about a second when its layout allows that and is then decoded on several threads, and a scan that is read in full shows its points while it is read, every second or at every tenth of them, also when many scans are opened together. Large E57 scans with that sample that are opened together are read one after another on each disk and indexed one after another, so the first is complete and detailed long before the last.
- A strip above the scene shows the progress and the time left of each import and each index build, and the stages of a section drawing, a closed mesh and a face detection, with a button to cancel.
- An index on disk (an octree) supplies the detail for the current camera, up to the point budget. It is built automatically for clouds of one million points or more, several at a time, and reused the next time the file is opened.
- The points on screen stay while the camera moves; the detail of the new view takes their place once it has been read.
- Four colour modes (stored colour, elevation, intensity, classification), eye-dome lighting, and a point size from 0.1 to 20, under Display beneath the view cube.
- The classes that occur in the open clouds are listed in the project panel and can be shown or hidden one by one.
- A view cube with a switch between perspective and orthographic (PERSP and ORTHO under it), seven camera directions, Zoom all and a right-click menu in the scene.
- Tabs in the document strip under the ribbon put the 3D model, opened views, drawings and sheets, and E57 photos side by side; Ctrl+Tab steps through them. A photo tab remembers its look while the model keeps its own camera, and the window remembers saved-view and drawing tabs.
- In an E57 photo, Compare with 3D shows the photo and the preceding model camera in two panes with a draggable divider. Use Stack panes or Side by side beside it to switch the layout. The comparison choice, orientation and divider ratio survive a restart. The photo remains interactive for picking and measuring. The 3D pane has its own orbit, pan, zoom and view-cube controls; its header opens that camera as the full model tab. Free tab dragging, 2 × 2 grids and detached windows are still planned in issue #16.
- Scanner stations of E57, PCD and PTX scans are shown as markers. Stations with photos are drawn as balls: click one to stand in that station and look around.
- Panoramas and photos taken along a path in an E57 file are marked along their path. Double-click a mark, or a photo under its scan in the project panel, to stand where it was taken: the photo lies over the points, a Photo slider sets how much,
Page UpandPage Downstep along the path, andEscreturns. Measuring and picking work on the points under the photo. - Colour from photos gives the points of a scan the colours its photos see them with, for a scan without colours or to replace them: only from photos that see a point unhidden, in the background, with Undo; exports write the new colours.
- Walk through the scene with
W,A,S,D, down and up withQandE, faster with Shift.
- A box with six draggable faces limits what is shown, selected, meshed and searched for faces, and its content can be exported on its own or drawn as a 2D drawing.
- Its limits can be typed as X, Y and Z coordinates in the Properties panel, fitted to the selection, or reset.
- The box can be turned about the vertical: type a Rotation (°) in Properties, or press Align to walls to turn it along the main direction of the walls inside it. Its faces, the cut planes of a 2D drawing and what it keeps then follow the walls of a building that stands at an angle to the axes of the scan.
- Where the box cuts a mesh, the cut looks solid: the material between two opposite faces of a wall, floor or ceiling, no farther apart than the Max. wall thickness (0.50 m by default), is filled on the faces of the box in one colour, as in a section drawing. A single surface, such as a facade scanned from one side, stays open. Fill the cut, Max. wall thickness (m) and Cap colour are under Section box in Properties.
- Box select selects every source point inside a rectangle drawn on screen; Pick point selects the one point of the active scan under the pointer and shows its coordinates and attributes.
- Delete hides the selected points. Undo and Redo go back and forward through up to eight edits: deletions, thinning and colours given from photos. Removing a scan empties that history.
- Thin reduces a cloud to an exact percentage of its points; Move and Scale shift and scale a cloud; all three are under Transform in Properties, and Reset transform there puts the cloud back.
- None of this changes the source file. Exports write the edited result.
- Distance measures between two picked points: the length, the horizontal length and the height difference. The command API also takes a line through more points, with each segment and the total length.
- Area measures a closed polygon: its area in its own plane (so a wall or a sloped roof is measured true), its area seen from above, and its perimeter.
- Points are picked from all points of the active scan, not only from the points on screen. A measurement is not saved with the scan.
- Lengths and areas are labelled in metres; the coordinates of the scan are taken as metres and are not converted.
- A saved view keeps the camera, the section box, the colour mode and its annotations, per scan.
- Note puts a text on a picked point; Line draws an arrow between two picked points.
- Export BCF writes all views of a scan as one BCF 2.1 file, each with its notes, camera, clipping planes and a picture of the scene.
- Export the active scan: the whole cloud, the selected points, everything but the selected points, the section box, or every Nth point, as LAS, LAZ, E57, PLY, XYZ, PTS or CSV.
- An unedited LAS, LAZ or E57 file exported to its own format is copied byte for byte. LAS and LAZ exports keep the original point records with their attributes and coordinate grid; filtered E57 exports keep the scans and their scanner positions.
- Merge visible LAS/LAZ scans… joins the visible LAS and LAZ layers into one file.
- Every export reads the full source of that scan, so no point is lost to what the screen shows.
- Section drawing, the 2D section button of the DRAWING group, makes a 2D drawing at scale 1:1 of what the section box cuts and saves it as DXF or DWG: a plan from the slab under the top face of the box, or a vertical section from the slab behind one of its four sides.
- While its block in Properties is open, the slab of the chosen view is outlined in blue in the scene, so that the cut plane of a vertical section is in sight. A slab of 0.10 m behind a face that lies outside the building holds no points; move that face onto a wall or make the slab thicker.
- In a box that is turned along the walls, the plan shows the walls along the axes of the drawing and the four sides are vertical sections parallel to the walls.
- The drawing holds the points of the slab, thinned to one per 5 mm, from every visible scan with its move and scale, without deleted points and hidden classes.
- Filled cut adds the walls, columns and floors that the slab goes through as filled regions with outlines, and leaves door and window openings open. Preview shows these regions over the points before a file is saved.
- Straight CAD lines adds closed, editable polylines of straight segments on a layer of their own,
OPS-STRAIGHT-LINES, beside the traced outlines and fills, for a plan and a vertical section, also in a turned box. Line tolerance (m) (0.01 m) limits how far they may leave the traced outline and Minimum line (m) (0.10 m) is the shortest segment they keep where they can; the preview draws them in blue. The same switch is in Create 2D plan / elevation / section…. - The choices are millimetres or metres, model coordinates or the corner of the box as zero, a layer per scan or per class, layer colours or the colours of the scan, and the file versions R2004 to R2018.
- Open in CAD viewer shows the saved DXF or DWG file read-only in Open CAD Studio, the open-source CAD application that comes with the application, and Open after export does so after every export; the same holds for faces and meshes saved as DXF or DWG. Without it, as in a build from source that did not build it, the program chosen in Settings or an installed Open CAD Studio is used, and otherwise the program the system has for the file.
- The Drawing view shows the drawing in the application itself in place of the 3D scene as soon as it is exported, or after a preview, and whenever it is chosen under VIEWS in the Project Browser: points, filled cut, outlines, frame and text on a light sheet, with a switch per layer, pan and zoom, a scale bar and the coordinates under the pointer. Any DXF or DWG file opens there too, from Drawing (DXF/DWG)… in the File menu.
- The filled cut is traced from the points and has limits: a wall scanned from one side is drawn as a thin strip, gaps under about half a metre are closed, and furniture in the slab is drawn unless its points are deleted first. The user guide lists them.
- SHEETS in the Project Browser holds sheets: paper from A4 to A0, lying or standing, with a border and a title block with the project, the name, the number, the scale, the date and who drew it. A sheet opens in a tab of its own.
- Drag a saved 3D view, a plan, an elevation or a section from VIEWS onto the paper, or use Place view in Properties. A drawing is placed as vectors at 1:100 or another scale, a 3D view as the picture of the view at about 200 dpi; each has its title under it, can be moved, scaled or resized, and follows its view.
- Export PDF… writes the sheet as a PDF the size of its paper.
- Text, Dimension, Leader and Line in Properties annotate a plan, an elevation or a section: a dimension snaps to the ends and corners of the lines and shows the distance in millimetres, rounded to the scale. Annotations stay with the drawing when it is made again, show on sheets and in the PDF, and are written to DXF and DWG as texts, real dimensions and leaders with Export DXF/DWG….
- Locked in Properties locks a saved 3D view, a drawing or a view on a sheet: a locked 3D view keeps its camera and section box, also while a drawing or a sheet lies in front of it, a locked drawing its crop region, and a locked view on a sheet its place and scale.
Mesh, the large button of the SURFACE group (its tooltip says Mesh Pointcloud), opens a card in three steps; Closed, Terrain, 3D mesh and Faces beside it open the card with that method chosen. The steps are the method, four cards that say what each makes and when to use it, with what it works on (the active scan, the section box and the selection, with about how many points); its options, each with its default and an explanation under the pointer, and Use recommended; and Run, with the progress, Cancel, and at the end the figures with Show in model, Export… and Back to options. A job goes on when the card is closed: the Mesh button stays highlighted and opens the card on its Run step, and the strip above the scene shows which step of a closed mesh or a face detection runs; Properties shows the progress of a terrain mesh or a 3D surface. Three of the methods turn the points of a scan, or the part of them inside the section box, into a mesh of triangles:
| Mesher | Use it for | What it gives |
|---|---|---|
| Terrain mesh | Ground, and other surfaces seen from above | A 2.5D surface from the lowest points of a grid, without walls and overhangs |
| 3D surface | A quick impression of a whole scan, walls and overhangs included | A surface from a sample of the points. It leaves holes and is not watertight |
| Closed mesh | A room or a part of a building of which the surface has to be right | A surface without overlaps from the region, closed wherever the scan has points or a gap narrower than the hole limit, with door and window openings left open; 100% of source points by default, or a deterministic smaller share for faster previews |
- Terrain mesh and 3D surface take the active scan, save an OBJ file with colours and normals and show the result in the scene.
- Closed mesh takes the active scan, or every visible scan that reaches the section box (layers of 3D BAG buildings stay out): put the box around a room and choose Run in Mesh Pointcloud. Its options say beforehand which region will be meshed, how large it is and about how many triangles it gives, and warns when that is more than a mesh may hold, or comes close to it without simplification. The result becomes the mesh of the active scan.
- The settings of a closed mesh are the voxel size (automatic: 2 cm for a region up to 20 m), the widest gap that is closed (0.25 m), how far simplification may move the surface (automatic: 0.15 voxel; 0 for none), and how the front of a surface is found: from the scanner stations where the scan knows them, towards the centre of the region, or upward.
- A closed mesh measures its result: the Run step, Properties and the status bar give the mean, the 95% and the largest distance between the points and the mesh, and how much of the surface had no station to take its side from, with advice when that matters.
- A closed mesh has limits: corners are rounded by about a quarter of a voxel, objects thinner than two or three voxels merge or get holes, some gaps beside another surface stay open, and without stations a surface that the centre of the region sees edge on can come out torn. The user guide lists them, with what was measured on generated rooms; nothing was measured on a scan of a real building yet.
- A scan holds one mesh, which stays with the scan when it is moved or scaled. A new mesh takes the place of the previous one, and Undo does not apply to meshes.
- Properties shows the vertices and triangles of a mesh, its open edges (the rims of the surface and of its holes) and the number of connected parts.
- Export mesh… saves any mesh that is open, whether made here, opened from a file or downloaded from the 3D BAG, as OBJ, as binary PLY or as binary STL, and as editable 3D geometry for CAD and BIM programs:
MESHentities in DXF or DWG, or an IFC4 element with a triangulated face set. - Texture surface… in Properties writes a coloured mesh as OBJ with UV coordinates, an MTL file and PNG atlas pages. It interpolates stored mesh vertex colours. Colours applied to points from E57 photos are carried into newly reconstructed surface meshes; reconstruct an older mesh again to include those edits. Set the texel size in metres and maximum atlas resolution in pixels in Properties before exporting; the CLI and MCP/API accept the same settings. Progress and cancellation are available while it runs; cancellation leaves no export files. The OBJ also retains vertex RGB so the native viewport can show its measured colours on reopening, although it cannot yet display the atlas image. This atlas writer does not yet project E57 photo pixels directly onto texels; CAD formats such as DWG do not retain texture images.
- Flat faces, the fourth method of Mesh Pointcloud, finds the flat faces of a region (floors, ceilings, walls and sloped planes) and its round columns and pipes, in the active scan or in every visible scan that reaches the section box: put the box around a room and choose Run in Mesh Pointcloud. A flat face is one plane with its outline, in which a window is a hole and a door a notch; a column or pipe is one cylinder with its axis, radius and scanned length, without an outline. It is not a mesh of the surface; the user guide says how the two differ.
- The settings are the distance tolerance (20 mm), the angle tolerance (10°), the smallest face (0.25 m²), whether cylinders are looked for and which scans take part. The options say beforehand which region will be searched and which voxel size the working budget gives for it, and warns when the region is so large that narrow faces and faces close together will be lost.
- The faces are kept with the active scan as a layer of their own beside its mesh, with a Faces switch in the project panel, and stay with the scan when it is moved or scaled. They are drawn in one colour per face, or coloured by the deviation of the points with a legend in millimetres.
- The Detected faces section of Properties lists the faces with their type, their area and the residual of their points (RMS). A click on a row highlights that face in the scene and shows its normal, the 95th percentile and the largest deviation of its points and its coverage, and for a cylinder its diameter, its length and the arc that was scanned.
- Export faces… under Detected faces in Properties, Export… on the Run step of Mesh Pointcloud and Detected faces… in the File view save them as a JSON file with the parameters of every plane and cylinder, as an OBJ mesh with a group per face, or as 3D geometry for CAD and BIM programs, in the coordinates of the scene. In DXF and DWG every flat face is a polyface mesh that shows its outline and openings, on a layer per type, and every cylinder its scanned surface with its axis as a line. In IFC4 every face is a building element with its measured values: a flat face as a polygonal face set with its openings, a column as an extruded circle along its axis. No ACIS solids are written. They are not saved with the scan: export them to keep them.
- Faces are marked out of date when points of a scan that took part are deleted, restored or thinned, when the index such a scan was read through is replaced, when one is closed, and when one of several scans that took part is moved or scaled. Clear faces removes them.
- The detection has limits: strips narrower than 0.15 m such as door reveals are no faces, a region too large for the working budget is searched with larger voxels, thin scans give fewer faces or none, round columns wider than about 0.7 m come out as strips of wall, and the side a face looks at is a guess where the scan knows no stations. The user guide lists them, with what was found on generated rooms; nothing was measured on a scan of a real building yet.
- 3D BAG buildings… in the File view downloads building models of the Netherlands for an area in RD New coordinates and shows them with a scan. It is a built-in extension that can be switched off on the Extensions page.
- Extensions from other authors add tasks: a folder or
.zipwith anextension.jsonand a program in any language, such as a PowerShell or Python script, that drives the window through the command API in a process of its own. Install extension… on File → Extensions checks it and shows what it declares before it is installed; installed extensions can be run from that page and their tiles appear on the New and Export pages. Writing an extension describes the format, with an example. - Settings has the language (the language of the system, English or Dutch) and the five colour themes of the OpenAEC style book.
- Display settings are kept between sessions. Settings and indexes are stored in the folders that the user guide names.
| Format | Read | Write | Notes |
|---|---|---|---|
| LAS, LAZ | yes | yes | Opens from the header; exports keep the original point records |
| E57 | yes | yes | Scanner positions, station photos, panoramas (spherical and cylindrical) and photos taken along a path are read, with the coordinate system the file states, and can colour the points. A pinhole photo with a pixel size of zero gives its focal length in pixels |
| PLY | yes | yes | Reads ASCII and little-endian binary; writes either |
| PCD | yes | no | ASCII, binary and compressed binary |
| PTX | yes | no | With the scanner position of each scan |
| PTS | yes | yes | |
| XYZ, ASC, TXT, CSV | yes | XYZ, CSV | Text with one point per line |
| OBJ | yes | yes | Mesh with colours and normals; material colours are read, texture images are not. --texture-mesh writes an OBJ with UV coordinates, MTL and PNG atlas from measured mesh vertex colours. Detected faces are written as OBJ too, with one group per face |
| PLY as mesh | yes | yes | Shown as faces. Written as binary PLY with double coordinates, and with colours and normals where the mesh has them |
| STL | yes | yes | Shown as faces. Written as binary STL: triangles only, without colours. A mesh more than 2,048 m from zero is written relative to a whole-metre origin that the file header names |
| OFF | yes | no | Shown as faces; can be saved as OBJ, PLY, STL, DXF, DWG or IFC |
| DXF | yes | yes, as a drawing and as 3D geometry | Read: ASCII DXF only. POINT entities open as points, 3DFACE entities as faces that can be saved as a mesh; other entities are skipped. Written: the 2D drawing of a section box, with points, filled regions, outlines and a line of text; and in 3D, in metres, detected faces as polyface meshes and a mesh as MESH entities, without ACIS solids. Not a format of the point exports |
| DWG | no | yes, as a drawing and as 3D geometry | The 2D drawing of a section box, as for DXF, in the versions R2004 to R2018; detected faces and meshes in 3D as for DXF, in version R2013. DWG files are not opened |
IFC4 (.ifc) |
no | yes | Detected faces and meshes as building element proxies with their measured values: flat faces as polygonal face sets with their openings, columns as extruded circles, meshes as triangulated face sets. Coordinates far from zero are relative to a local origin that the site carries |
Faces as JSON (.json) |
no | yes | The detected faces of a scan: every plane and cylinder with its parameters and the residuals of its points, the outline of every plane, and the edges between flat faces. The user guide describes every field |
BCF 2.1 (.bcf) |
no | yes | Saved views with notes and pictures |
| PNG | no | yes | Picture of the 3D view, through the command API |
Scan project file (.rcp) |
yes | no | Only the list of scans is read. The indexed scan copies (.rcs) of a project are a closed format and are not read |
These are measurements, each on the data named. The processor, memory and disk of the computer they were taken on were not recorded, so read the times as an order of magnitude and not as a benchmark. The rows of 3 October 2026 compare release builds for Windows; for the other rows the record does not name the system. native/TEST_DATA.md has the full record and says where the public data comes from.
| What | Data | Result | Date |
|---|---|---|---|
| Points on screen while the camera moves, at a budget of 6 million | Synthetic scene of 40 million points, LAS 1.2 with colours, 1.04 GB | Never fewer than 2.96 million; full detail of the new view after about 0.6 to 1.2 s, with the index in the file cache of the system | 3 Oct 2026 |
| Building the index | The same file | About 11 s | 3 Oct 2026 |
| Reading a whole file | Binary PLY of 3.2 GiB, 114,174,907 points, made from public AHN6 tiles | 18.13 s, 32,836 KiB peak memory | 1 Oct 2026 |
| Reopening that file with its index | The same file | 0.15 s, 18,712 KiB peak memory | 1 Oct 2026 |
| Selecting the points in a box of 100 by 100 by 100 m | The same file | 432,975 points in 0.56 s with the index; about 29 s without | 1 Oct 2026 |
| Reopening a text file with its index | XYZ of 2.58 GB, 45,839,678 points, from a public AHN6 tile | 0.10 s, 8,288 KiB peak memory | 2 Oct 2026 |
Exporting a section with --section |
Public AHN6 tile, LAZ, 45,839,678 points; 125,763 points written | 17.58 s, 148,976 KiB peak memory | not recorded |
| A budget of 10 million points | LAZ of 1.2 GB, 114,174,907 points, merged public AHN6 tiles | 5,451,630 points in view after about 4 s; about 641 MiB process memory | not recorded |
The section drawing, the closed mesh and the face detection were measured on generated rooms only; the user guide has those figures in the section of each tool.
Limits in the application:
| Limit | Value |
|---|---|
| Point budget | 250,000 by default; 1,000 to 10,000,000 with Points in view beneath the view cube and through the command API |
| Automatic index | For clouds of 1,000,000 points or more; can be switched off with Auto-index |
| Undo | 8 deletions |
| Saved views | 32 per scan, each with at most 64 annotations; a note has at most 240 characters |
| Measurement | 256 points |
| Section drawing | 150,000 points by default and at most 400,000; when the slab holds more after thinning to 5 mm, the point spacing doubles. Writing takes about 2.8 kB of memory per point: about 1.1 GB at 400,000 |
| Filled cut of a section drawing | A grid of at most 16 million cells: 80 by 80 m at the default cell of 20 mm, with larger cells beyond that. Gaps up to the largest wall thickness (0.50 m by default, at most 2 m) are closed |
| Mesh | 4,000,000 vertices and 8,000,000 triangles, for a mesh file and for a mesh job alike. Such a mesh takes about 0.25 GB of memory, 0.55 GB while it is shown, and up to 0.9 GB for a moment while a file of that size is opened |
| Meshes shown together | About 5.6 million vertices and 22 million triangles: what fits in the two buffers of 256 MiB each that the graphics card takes for them. One mesh always fits; one that does not fit beside the others is held, and can be saved, but is not drawn |
| Terrain mesh | 100,000 vertices |
| 3D surface | 3 to 1,000,000 vertices (50,000 by default), and an optional minimum mesh size |
| Closed mesh | Voxels of 0.005 to 0.5 m; 0.01 to 100% of the source points; gaps closed up to 3.2 m and at most 32 voxels; a scan without an index up to 5,000,000 points. About 2 GB of memory for the blocks in work |
| Detected faces | Distance tolerance 1 to 500 mm, angle tolerance 1 to 45°, smallest face 0.01 to 10,000 m². A working set of 1,500,000 voxels of 30 mm, beyond which the voxels double; at most 4,096 faces per job, of which Properties lists the 200 largest flat faces and the 200 largest cylinders; cylinders with a radius of 0.01 to 1 m |
| 3D BAG download | 2 by 2 km and about 5,000 buildings |
An index can take several gigabytes on disk for a large survey.
The first argument chooses a mode. Without one, the arguments are files, folders and scan project files to open in the window. The first two modes below open the window, --mcp runs until its input is closed, and the others do their work and end without a window.
| Mode | What it does |
|---|---|
open-pointcloud-studio [INPUT ...] |
Opens the window with the scans, scan folders and scan project files given |
--api-port PORT [INPUT ...] |
Opens the window with its command API on a fixed port |
--mcp |
Serves the commands as MCP tools on standard input and output, without a window of its own |
--list-scans PATH [PATH ...] |
Prints the scan files found in files, folders and scan project files |
--index INPUT |
Builds the index of a scan and keeps it for later |
--scans INPUT |
Prints the scanner positions stored in a scan |
--photos INPUT OUTPUT_DIRECTORY |
Saves the photos of a scan as image files |
--export INPUT OUTPUT |
Converts a scan; the extension of OUTPUT chooses the format (.ply, .xyz, .pts, .csv, .las, .laz, .e57) |
--section INPUT XMIN,YMIN,ZMIN,XMAX,YMAX,ZMAX OUTPUT [--rotation DEGREES] |
Exports the points of a scan that lie inside a box; with --rotation the box is turned that many degrees counter-clockwise about the vertical through its centre |
--drawing INPUT XMIN,YMIN,ZMIN,XMAX,YMAX,ZMAX OUTPUT.dxf|.dwg [--view plan|front|back|left|right] [--rotation DEGREES] [--thickness METRES] [--units mm|m] [--fill on|off] |
Draws the slab behind one face of a box in a scan as a 2D drawing in DXF or DWG: a plan with a slab of 0.10 m in millimetres unless the options say otherwise |
--merge OUTPUT.laz INPUT1.las INPUT2.laz [...] |
Merges LAS and LAZ scans into one file |
--mesh INPUT OUTPUT.obj |
Writes a terrain mesh of a scan |
--surface INPUT OUTPUT.obj [--max-vertices N] [--neighbors N] [--edge-factor N] [--mesh-size SIZE] |
Writes a 3D surface mesh of a scan; reads the points from the index of the scan when it has one |
--texture-mesh INPUT_MESH OUTPUT.obj [--texel-size METRES] [--max-resolution PIXELS] |
Writes a coloured OBJ mesh with an MTL and one or more PNG texture atlases from the measured colours at its vertices; requires a new output name |
--closed-mesh INPUT OUTPUT.obj|.ply|.stl|.dxf|.dwg|.ifc [--box XMIN,YMIN,ZMIN,XMAX,YMAX,ZMAX] [--rotation DEGREES] [--voxel METRES] [--max-hole METRES] [--simplify MILLIMETRES] [--sample-percent P] [--sides automatic|centre|upward] |
Writes a closed mesh of a scan, or of a box in it, as OBJ, PLY, STL, DXF, DWG or IFC; P selects a deterministic source share (100% by default) |
--faces INPUT OUTPUT.json|.obj|.dxf|.dwg|.ifc [--box XMIN,YMIN,ZMIN,XMAX,YMAX,ZMAX] [--rotation DEGREES] [--distance METRES] [--angle DEGREES] [--min-area SQUARE_METRES] [--cylinders on|off] |
Detects the flat faces and the cylinders of a scan, or of a box in it, and writes them as JSON, OBJ, DXF, DWG or IFC: with a distance tolerance of 0.02 m, an angle tolerance of 10 degrees, faces from 0.25 m² and cylinders on unless the options say otherwise |
--survey INPUT OUTPUT.json |
Surveys a scanned building for Pointcloud to Drawing and writes what was found as JSON: the box around the building without stray points far out, the main direction of its walls, its footprint, the occupied cells of 5 by 5 by 2 cm per height, and its levels: every floor with its ceiling, slab, slope and cut height, the roof, the ground and P |
--mesh-export INPUT OUTPUT |
Writes the faces of a mesh file as OBJ, PLY, STL, DXF, DWG or IFC; the extension of OUTPUT chooses the format (.obj, .ply, .stl, .dxf, .dwg, .ifc) |
--bag3d XMIN,YMIN,XMAX,YMAX 1.2|1.3|2.2 OUTPUT.obj |
Downloads the 3D BAG buildings inside an RD New box as OBJ |
--version, -V |
Prints the version |
--help, -h |
Prints the modes |
open-pointcloud-studio --export scan.laz scan.e57
open-pointcloud-studio --section scan.laz 207440,474000,-100,208000,475000,1000 crop.laz
open-pointcloud-studio --merge merged.laz north.laz south.laz
open-pointcloud-studio --drawing scan.laz 0,0,0,20,15,1.1 plan.dxf
open-pointcloud-studio --drawing scan.laz 0,6,-1,20,15,8 section.dwg --view front --units m
open-pointcloud-studio --drawing scan.laz 0,6,-1,20,15,8 along-wall.dxf --view front --rotation 30
open-pointcloud-studio --closed-mesh scan.e57 room.ply --box 0,0,-0.1,5.1,4.1,2.7
open-pointcloud-studio --faces scan.e57 room-faces.json --box -0.1,-0.1,-0.1,5.1,4.1,2.7Every window runs a command server on 127.0.0.1. It writes its port and a token to a discovery file: instance-<pid>.json in %APPDATA%\open-pointcloud-studio-native\instances\ on Windows, and in ~/.config/open-pointcloud-studio-native/instances/ on Linux and macOS (or under $XDG_CONFIG_HOME when that is set). A command is one JSON object sent with that token:
curl -H 'Content-Type: application/json' -H 'X-OPS-Token: TOKEN' \
-d '{"command":"status"}' http://127.0.0.1:PORT/execThe commands open and close scans, set the camera, the section box and the display, select, delete, measure, save views, export, draw sections, mesh, detect faces, download 3D BAG buildings, run extensions and take pictures of the 3D view. The server listens on the loopback address only and refuses a command without the token. native/API.md lists every command, and Writing an extension shows how a program of its own adds a task to the window through it.
open-pointcloud-studio --mcp runs a Model Context Protocol server on standard input and output. It offers a tool for every command of the command API, tools that wait for long tasks, a screenshot tool that returns the 3D view as an image, and tools to list, choose and start windows. A client program starts it with a configuration like this one:
{
"mcpServers": {
"open-pointcloud-studio": {
"command": "/usr/bin/open-pointcloud-studio",
"args": ["--mcp"]
}
}
}command is the full path of the executable, with every part written out: most clients fill in neither %LOCALAPPDATA% nor ~, and JSON needs every backslash doubled. Starting names the paths, and native/MCP.md says more about starting the server from a client and lists every tool.
open-pointcloud-studio-api is the service of the point-cloud core for programs and servers, without a window. A request carries a point-cloud file, and the service runs one of five tools on it: inspect reports what the file holds, convert writes it as LAS, LAZ, E57, PLY, XYZ, PTS or CSV (also only the points in a box, turned or not), section_drawing draws a section as DXF or DWG, and terrain_mesh and surface_mesh make OBJ meshes. They are the operations of the command line, run by the same code. REST and MCP (POST /mcp) answer on one port, with bearer keys, the same JSON errors on every route and an OpenAPI document at /v1/openapi.json; nothing is kept between calls. It is licensed under LGPL-3.0-or-later, as the core.
A release publishes it as a container image for Linux x86-64, ghcr.io/openaec-foundation/open-pointcloud-studio-api:VERSION; the release notes give its digest and how to check its attestation:
gh attestation verify oci://ghcr.io/openaec-foundation/open-pointcloud-studio-api@sha256:DIGEST --repo OpenAEC-Foundation/open-pointcloud-studioTo try it on your own computer, without keys and on the loopback address only:
cd native
OPENAEC_API_TOEGANG=open cargo run -p open-pointcloud-studio-api -- --http 127.0.0.1:8080docs/cloud-api.md describes the routes, the tools and their arguments, the keys, the limits, the errors and the container; bash deploy/cloud-api/smoke.sh URL KEY --version VERSION tests a running service. The deployment definition in deploy/aws is prepared and not deployed yet.
The point-cloud core is also a library for programs of your own. From C, C++ or any language that calls C, it is ops_pointcloud: 15 functions, declared in ops_pointcloud.h with ABI version 1.0, that open, inspect, read, crop, export and index point clouds. Each release carries it in four archives, for Windows x64, for macOS and for Linux on x86-64 and on 64-bit ARM (see Download and install), each with the header, an example and the notices. From the unpacked folder on Linux or macOS:
cc -std=c11 -Wall -Iinclude examples/inspect.c -Llib -lops_pointcloud -Wl,-rpath,"$PWD/lib" -o inspect
./inspect .From Rust, the crate pointcloud-core is used by the git tag of a release, through the module pointcloud_core::ops:
pointcloud-core = { git = "https://github.com/OpenAEC-Foundation/open-pointcloud-studio", tag = "vYYYY.W.N", default-features = false }The library is licensed under LGPL-3.0-or-later. docs/library.md gives the boundary, the compatibility rule, the rules of the C interface for buffers, errors and threads, and what the licence asks of a program that uses it.
docs/ecosystem.md records what is delivered for each system, from the packages to the library and the service, and how each part is verified.
You need the stable Rust toolchain. On Debian and Ubuntu, also install the development packages the window library links:
sudo apt-get install pkg-config libxkbcommon-dev libwayland-dev libx11-devThen:
cd native
cargo build --release -p open-pointcloud-studio-native
cargo test --workspace
cargo clippy --workspace --all-targets -- -D warningsThe executable is native/target/release/open-pointcloud-studio, with .exe on Windows. cargo run -p open-pointcloud-studio-native -- scan.laz builds and starts a development build with a file.
Open CAD Studio, which the packages carry, is not part of this repository. This script fetches the commit of its repository that native/packaging/open-cad-studio.pin names, checks that it is that commit, and builds it in a Cargo workspace of its own. It needs git and a C++ compiler besides Rust, and on Debian and Ubuntu also libxcursor-dev libxi-dev libxrandr-dev libgl1-mesa-dev libfontconfig1-dev libfreetype6-dev:
bash native/packaging/build-open-cad-studio.sh -j 4It writes native/target/open-cad-studio/release/OpenCADStudio, where a development build of the application finds it. native/README.md says more.
native/README.md has notes for developers, and native/packaging/README.md describes how the installer and the packages are built and how a release is made.
| Path | What it holds |
|---|---|
native/core |
The point-cloud library: readers and writers, the index on disk and the reads from it, export, meshing, 2D drawings, face detection and the 3D BAG client, and ops, the whole-file operations that the command line, the cloud API and the C library share |
native/desktop |
The desktop application: window, 3D view, selection and the other tools, command API and MCP server |
native/server |
The cloud API, open-pointcloud-studio-api: REST and MCP over HTTP |
native/sdk |
The C library ops_pointcloud: its header, its example and the scripts that pack its archives |
native/examples |
A Rust program with a workspace of its own that uses the core as another repository would |
native/tools |
third-party-notices.py, which writes the notices of the crates that the image of the cloud API and the archives of the C library carry |
native/ui |
openaec-ui, the shared interface crate of OpenAEC desktop tools, copied from the OpenAEC Style Repo: title strip, ribbon and document tabs, panels, the property grid, the Settings dialog, the File menu and the status band |
native/assets |
Fonts, icons and the Dutch interface texts |
native/extensions/examples |
An example extension, in PowerShell and Python |
native/installer, native/packaging |
The Windows installer script and the packaging of all systems |
deploy |
The container image of the cloud API with its smoke test (deploy/cloud-api), and its prepared deployment definition (deploy/aws) |
docs |
The user guide and its images, the source of the Dutch manual of the wiki (docs/wiki), the guide for authors of extensions, and the references of the cloud API and the C library |
docs/ecosystem.md |
The record of what is delivered for each system and how each part is verified |
promo |
The feature video, its poster and stills, and the scripts that capture and render them |
screenshots |
Pictures taken while the first native versions were developed; none of them shows the current interface |
classic |
An earlier application, kept for reference and no longer developed |
- The point-cloud library
native/coreis licensed under LGPL-3.0-or-later; see LICENSE.md. - The cloud API
native/serverand the C librarynative/sdkare licensed under LGPL-3.0-or-later, as the core. The image of the cloud API and the archives of the C library carryTHIRD-PARTY-NOTICES.txtwith the crates they are built from,LICENSE-LGPL-3.0.mdandLICENSE-GPL-3.0.txt. - The desktop application
native/desktopis licensed under GPL-3.0-only; see native/desktop/LICENSE-GPL-3.0. Its ribbon and properties rows are adapted from OpenCADStudio, which is GPL-3.0, and it uses that project's SVG icons. - The shared interface crate
native/ui(openaec-ui) is licensed under LGPL-3.0-only; its fonts keep the SIL Open Font License 1.1, one icon the Apache License 2.0 and the vectors from the OpenAEC style book CC BY-SA 4.0, which itsCargo.tomlstates asLGPL-3.0-only AND CC-BY-SA-4.0 AND OFL-1.1 AND Apache-2.0; see native/ui/NOTICE.md. - Open CAD Studio, which every package carries, is licensed under GPL-3.0 by its authors. Its source is not part of this repository: native/packaging/open-cad-studio.pin names the commit of its repository that the packages are built from, and every release carries the source of that commit as
open-cad-studio-source_SHORT.tar.gzand the crates it takes from git repositories, some of them under the MPL-2.0 or the LGPL-2.1-or-later, asopen-cad-studio-vendor_SHORT.tar.gz. The packages carry its licence text asOpenCADStudio-LICENSE.txtand a notice with the commit asOpenCADStudio-NOTICE.txt. - The fonts Inter and Space Grotesk, as the OpenAEC style book carries them, are bundled under the SIL Open Font License 1.1; see native/assets/fonts.
- The Rust libraries the application links are recorded in
native/Cargo.lock, each under its own licence; native/NOTICE has the third-party notices. - Building models come from 3DBAG (CC BY 4.0), and the map in the 3D BAG panel from Kadaster through PDOK (CC BY 4.0). The application shows both credits, and files it saves from 3DBAG carry the credit.
Every package carries the licence texts.
- Report a problem or ask for a feature in the issues. Say which system and version you use (the version is in the middle of the status bar and in Settings > About) and, if you can, which format the file has and how large it is.
- A pull request must pass
cargo test --workspaceandcargo clippy --workspace --all-targets -- -D warnings. The checks run them on Linux, Windows and macOS. - Test data is generated by the tests or comes from public data sets; native/TEST_DATA.md lists the public ones. Do not add scans of real projects, or screenshots of them, to the repository.
- A text of the interface is written in English in the source and looked up in
native/assets/locales/nl.json. A new text needs an entry there; the tests fail when a text has no entry or an entry is no longer used. - A new command-line mode is one entry in
native/desktop/src/cli_help.rsand one row in the table above; a test holds the two to each other and to the code. A new command of the API gets a row innative/API.md, a tool, and the tool's row innative/MCP.md; the tests fail when a command, its row or its tool is missing, or when a row does not name an argument of its tool. A release that adds a command or a field raisesAPI_REVISIONinnative_api.rsand adds a row under API changes innative/API.md.