The Open-Source
SketchUp File Toolkit
Parse, write, and convert .skp files without SketchUp — natively in Python, TypeScript, .NET, Dart, and C++. No SDK. No license. Just code.
One format, five native ports
Not bindings around a shared core — each language independently parses, writes, and converts the same reverse-engineered binary format. Swipe or pick a tab.
Every port is reverse-engineered and tested independently, then cross-validated against real .skp files so the same file produces the same geometry, layers, and materials in every language.
No SketchUp SDK involved at build or save time — every language's writer splices new class-ref/back-ref entities into a small, disclosed, SDK-authored blank-document scaffold, the same protocol the reader decodes, inverted.
7 formats, written from scratch in every language — no third-party CAD/BIM SDK involved. The DXF converter specifically is verified against real desktop AutoCAD, not just lenient readers.
See it parse, live
This is the actual web viewer, running right below — drag in a real .skp file and watch it parse entirely in your browser, no upload to any server.
Live from the registries
Real numbers, fetched directly from each source in your browser — no server, no cache, nothing hidden.
PyPI's public API doesn't reliably expose download counts, so it's not shown live here — everything else on this page is fetched live from each source itself.
Python's version badge above only reflects PyPI — it also has an unreleased GitHub-only 1.3.0. C++'s badge only reflects numbered GitHub releases — it too has an unreleased GitHub-only preview. See below.
Language & Version Support
Which of the 5 languages has which feature, what's unreleased, and which real SketchUp file versions actually parse — the honest picture, not a marketing gloss.
| Feature | Python | TS | .NET | Dart | C++ |
|---|---|---|---|---|---|
| Parse VFF (2021+) & legacy MFC (2013–2020) | ✅ | ✅ | ✅ | ✅ | ✅ |
| Attribute dicts: multi-dict support | ✅ | ❌ | ❌ | ❌ | 🔶 unreleased |
| Attribute dicts: full 9-value-type support | ✅ | ❌ | ❌ | ❌ | ❌ str only |
| Legacy pages/scenes, construction lines/points reading | ✅ | ❌ | ❌ | ❌ | 🔶 unreleased |
| Writer: dimensions, section planes, construction geometry | ✅ | ❌ | ❌ | ❌ | ❌ |
| Export: GLB/OBJ/STL/PLY/DXF/IFC4/JSON | ✅ | ✅ | ✅ | ✅ | ✅ |
| IFC export fixes (units, layer visibility, Psets) | 🔶 unreleased | not checked | not checked | not checked | 🔶 unreleased |
| Fragments (.frag) export | 🔶 unreleased | 🔶 PR open, CI red | ❌ | ❌ | 🔶 unreleased |
✅ shipped & released · 🔶 shipped on main, not released · ❌ not yet ported. This is the condensed version — the full matrix covers every feature.
| SketchUp version | Result | Notes |
|---|---|---|
| 2014–2018, 2020, 2021, 2025 | ✅ Clean | Parse, build, export cleanly |
| V3, V4, V6, V7, V8, 2013, 2019 | ❌ Fails | 5 distinct errors — tracked in issue #284 |
A real 14-file version sweep — not every old-format file parses today, stated plainly rather than glossed over. Full per-version error table: LANGUAGE_PARITY.md.
Built for real production files
Reverse-engineered from scratch. Cross-validated on real files, not just against itself.
Both Container Eras
Modern VFF/ZIP (2021+) and classic MFC CArchive (2013–2020) — auto-detected, same output shape either way.
Full Geometry & Materials
Vertices, edges, faces, UVs, layers, materials, textures, styles, and dynamic component attributes.
Streaming, Not Materializing
Peak memory bounded by the largest single definition — verified on real files up to 620 MB / 153,586 definitions (.NET) and 294 MB / 336,254 definitions (Python), no crash.
Opt-in Scene Baking
Full placed scene graph, triangulated, world-space, GLB-ready — kept separate from the light default parse.
Structured Observability
Opt-in progress reporting and location-carrying parse errors — silent by default, in every language's idiomatic form.
No SDK, No License
Pure, from-scratch reverse-engineered implementations. No SketchUp installation, no proprietary dependency, ever.
Convert to any format
OpenSKP is a genuine SketchUp file converter, not just a reader with an export bolt-on — 7 formats, written from scratch in every language, no third-party CAD/BIM SDK involved.
glTF 2.0 (GLB)
Binary glTF for web, AR, and game engines — triangulated, PBR materials, ready for GPU upload.
Wavefront OBJ / MTL
The universal 3D interchange format, with a companion .mtl material library.
STL
ASCII or little-endian binary, ready for slicers like Cura, PrusaSlicer, and Bambu Studio.
PLY
Stanford Triangle Format with vertex colors and normals — ASCII or little-endian binary.
AutoCAD DXF
3DFACE or Polyface Mesh, R2000 compliant — verified against real desktop AutoCAD, not just lenient DXF readers.
IFC4 (BIM)
ISO 10303-21 STEP with full spatial hierarchy and element classification — validated with IfcOpenShell.
Full Metadata JSON
The entire model — geometry, materials, layers, hierarchy, dynamic properties — as one queryable JSON document.
Fragments (.frag) 🐍 Python + ⚙️ C++, preview
Direct export to ThatOpen's public Fragments/FlatBuffers format for BIM web viewers — no IFC intermediate. Python and C++ today, neither on a package registry yet — install from the tagged GitHub release (Python, C++). C++ measured roughly 5-9x faster end to end than the Python pipeline on the same real files. TypeScript/.NET/Dart ports haven't landed.
Write native .skp files, too
Not just a parser — a genuine, from-scratch .skp writer, validated feature-by-feature against the real SketchUp SDK. ✅ All 5 languages
Materials, Textures & Layers
Solid-color and PNG/JPEG-textured materials, and named layers with their own color and default visibility.
Definitions, Instances & Groups
Reusable component definitions with multiple instances, groups, and nesting to any depth — an assembly of its own sub-parts.
Curves & Faces with Holes
Genuine, editable-by-radius circles and arcs, freeform polylines, and faces with one or more holes cut out.
Rotation, Visibility & Attributes
Instance/group rotation and hidden state, plus custom key/value metadata — the same mechanism SketchUp's own dynamic components use.
Explicit Texture Positioning
Scale, rotate, shear, and offset a texture independently per side — on a face of any orientation, tilted or not.
Edit Existing Files
open_existing() loads a real .skp file, reuses its materials/layers/definitions, and lets you extend it before saving.
Generate Rebuild Code
to_python_code() turns a parsed .skp file into a re-runnable source-code transcript, not a builder — a diffable, editable snapshot instead of an opaque binary.
from openskp import create
builder = create()
red = builder.add_material("Red", (255, 0, 0))
with builder.add_component_definition("Chair") as chair:
chair.add_face([(0, 0, 0), (20, 0, 0), (20, 20, 0), (0, 20, 0)])
builder.add_instance(chair, translation=(50, 0, 0))
builder.add_face([(0, 0, 0), (100, 0, 0), (100, 100, 0), (0, 100, 0)], material=red)
builder.save("output.skp")from openskp import open_existing
builder, warnings, definitions = open_existing("building.skp")
builder.add_instance(definitions["Window"], translation=(0, 300, 0))
builder.save("building_edited.skp")from openskp import SkpFile, to_python_code
model = SkpFile.open("building.skp").parse()
print(to_python_code(model)) # a re-runnable create() transcript, as textEvery feature above has been validated feature-by-feature against the real SketchUp SDK, not just against this project's own reader — and it holds up rebuilding complex, real architectural models, not only synthetic test fixtures. Landed in Python first; TypeScript, .NET, Dart, and C++ (1.1.0) now match it feature-for-feature, each verified against the same SDK oracle.
Built by AI, too
The writer's generic API — no add_chair() or add_staircase() helpers — turns out to be an unusually good target for AI coding agents. Every model below was generated from a natural-language or reference-photo prompt, by two independent AI agents, using nothing but the raw create() API.
Pick your language
The API is equivalent across all five — copy, paste, parse.
pip install openskpfrom openskp import SkpFile
model = SkpFile.open("my_model.skp").parse()
print(model.version, len(model.layers))
scene = SkpFile.open("my_model.skp").build_scene()
print(len(scene.glb_primitives), "mesh primitives")OpenSKP can also write and convert .skp files, not just parse them.
npm install openskpimport { SkpFile, toGLB } from 'openskp'
const model = SkpFile.open('my_model.skp').parse()
const scene = SkpFile.open('my_model.skp').buildScene()
const glb = toGLB(scene)OpenSKP can also write and convert .skp files, not just parse them.
dotnet add package OpenSkpusing OpenSkp;
var model = SkpFile.Open("my_model.skp");
var scene = SkpFile.BuildScene("my_model.skp");
Console.WriteLine($"{scene.GlbPrimitives.Count} mesh primitives");OpenSKP can also write and convert .skp files, not just parse them.
dart pub add openskpimport 'package:openskp/openskp.dart';
final model = SkpFile.open('my_model.skp').parse();
final scene = SkpFile.open('my_model.skp').buildScene();
print('${scene.glbPrimitives.length} mesh primitives');OpenSKP can also write and convert .skp files, not just parse them.
find_package(OpenSkp CONFIG REQUIRED)
target_link_libraries(your_target PRIVATE OpenSkp::OpenSkp)#include <openskp/openskp.hpp>
auto skp = openskp::SkpFile::open("my_model.skp");
auto model = skp.parse();
auto scene = skp.build_scene();OpenSKP can also write and convert .skp files, not just parse them.
Downloads & releases
Every package, its current version, and where to get it — updated automatically from each registry.
Recent changes
Full release notesDirect SketchUp → ThatOpen Fragments (.frag) export with no IFC intermediate — now in both Python and C++, with C++ measured 5-9x faster end to end on real files. Also 4 IFC export correctness fixes, and a fix so every attribute dictionary an instance carries (not just SketchUp's own dynamic attributes) actually reaches GLB/JSON metadata export, in both languages. GitHub-only preview tags, not on PyPI or a numbered C++ release yet. Read the full write-up →
The writer's custom attribute dictionaries gain full type support in Python and a real multi-dictionary API; groups can carry attributes in all 5 languages for the first time; applied texture width and material opacity round-trip correctly everywhere; SketchUp Image entities and the SKP-to-code generator reach parity across every language port. Read the full write-up →
The .skp writer landed in Python first; this release ports the identical feature set — geometry, materials, layers, component definitions and groups, curves, custom attributes, and file editing — to TypeScript, .NET, Dart, and C++, each verified against the real SketchUp SDK. Read the full write-up →
Native OBJ/MTL, STL, PLY, DXF, and IFC4 (BIM) exporters across all five ports, plus a from-scratch fix that makes DXF export actually open in real desktop AutoCAD — not just pass lenient readers. Read the full write-up →
Fixed the published npm README, which was still showing a pre-implementation placeholder page from before the TypeScript port existed.
.NET and Dart ports built from scratch to parity with Python/TypeScript. Opt-in scene baking, streaming memory architecture for 100,000+ definition files, and structured observability (progress + location-carrying errors) shipped across all four languages.
API at a glance
Two entry points, the same shape in every language. Full reference lives in the Developer Guide.
.parse()
Light, default
Reads each definition's geometry exactly once — vertices, edges, faces, and un-resolved instance placements. No scene-graph walking, no triangulation.
version | SketchUp file-format version string |
definitions | Component/group geometry, keyed by ID |
layers | Layer names + RGB colors |
materials | Colors, transparency, embedded textures |
.build_scene()
Opt-in, heavier
Walks the entire placed scene graph — every instance, transform-resolved to world space, triangulated and grouped into GLB-ready mesh primitives.
scene_hierarchy | World-space instance tree |
glb_primitives | Triangulated positions/normals/indices |
mesh_index | Metadata per baked mesh |
gltf_materials | glTF PBR material definitions |
Used in production
OpenSKP isn't just a library — it's the SketchUp-parsing engine behind real, actively-used applications.
FrameSmart
A 3D collaboration platform for viewing, sharing, and collaborating on 3D models together with their metadata (IFC, SketchUp, and more) — hosted on Linux, with nearly 200 active users.
How they use it: OpenSKP powers FrameSmart's entire SketchUp import pipeline, end to end — every .skp file a user uploads is parsed and converted through it.
IngeTrazo
A free, Linux-first 3D modeler for civil engineering and architecture — a SketchUp alternative with a BIM → IFC bridge.
How they use it: OpenSKP replaced IngeTrazo's Wine + proprietary SketchUp DLL dependency as its native .skp import backend, removing the Windows-only dependency entirely.
Using OpenSKP in your own project? Open an issue or a PR to get listed here.
Contributors
This project would not be possible without them.
