N23D is written in 100% Rust, end to end — no C++ kernel wrapped in a friendlier language, no patchwork of acquired engines held together by connectors and nightly syncs.
What memory safety actually means. Rust enforces ownership and borrowing at compile time: every piece of data has a clear owner, and the compiler proves that no one is reading memory that has been freed, writing past the end of a buffer, or mutating the same value from two threads at once. That entire class of bug — use-after-free, buffer overflow, data race — is rejected before the program ever runs, rather than caught later by sanitizers, hardening flags and patch cycles.
The stack the rest of the industry is standing on. Mainstream CAD, CAM and PLM systems rest on geometry kernels and codebases that began in the 1980s and 90s, written in C and C++. Around them sit huge native plugin ecosystems, scripting hosts, IPC layers, and — most exposed of all — parsers for STEP, IGES, DWG, JT and a long tail of proprietary formats. Engineering files arrive from suppliers, customers and marketplaces, and those parsers read them with full process privileges. That is the textbook shape of a memory-unsafety attack surface: complex binary input, decades-old native code, third-party extensions running in-process.
- A malicious or malformed supplier file should be a rejected import, not code execution.
- A plugin should not be able to corrupt the geometry kernel it is loaded into.
- A crash in a solver should not be able to take the product record with it.
- Security should be a property of the runtime, not a wrapper bolted around an unsafe core.
Why a wrapper is not an answer. You cannot make an unsafe kernel safe by putting a modern UI, a cloud tenant or a compliance badge in front of it. The risk lives where the memory is handled. If your entire digital thread — CAD, CAM, CAE, ERP, CRM, PLM — ultimately reads and writes through a legacy native engine, then your IP, your BOMs and your customer data inherit that engine’s failure modes.
What N23D does instead. One memory-safe runtime under the whole thread. Rust’s guarantees are what make it reasonable to keep design, manufacturing, simulation and business records in one shared model in one process: safe concurrency across cores, no garbage-collector pauses on large assemblies, and no unsafe legacy kernel underneath the crown jewels. Safety and the single source of truth come from the same design decision.
Start with the platform, or read the stack: CAD · CAM · CAE · ERP · CRM · PLM.
