F3D: Fast, Minimalist 3D Viewer and Rendering Library
What F3D is
F3D (the README says it is pronounced /fɛd/) describes itself as "a fast and minimalist 3D viewer desktop application". It opens a long list of formats, "from digital content to scientific datasets, including glTF, USD, STL, STEP, PLY, OBJ, FBX, and Alembic", plays animations, generates thumbnails and offers rendering options up to physically based rendering and, in builds that include it, raytracing. The application is "fully controllable from the command line and supports configuration files", and the same repository ships libf3d, "a simple library to render meshes, with a C++17 API and C, Python, Java, and JavaScript bindings".
The vision section is explicit about scope. F3D wants to be "usable non-interactively", and it has "no plan to" provide a menu-and-button UI, data processing tools or an export feature. It is a viewer and renderer, not an editor or a converter.
Desktop users get a quick viewer with drag and drop, hotkeys and file-manager thumbnails. Developers get a permissively licensed library that turns a 3D file into a PNG in a few lines, with offscreen backends for servers and CI. This page concentrates on the library, the part that can be tested on a headless machine. F3D was started at Kitware SAS by Joachim Pouderoux, Michael Migliore and Mathieu Westphal and is now published "By the F3D-APP Foundation". The repository f3d-app/f3d was created on 17 February 2020, is written in C++ and is licensed BSD-3-Clause.
How it works
VTK underneath, readers as plugins
F3D is built on VTK. The acknowledgments list it first, followed by OCCT (OpenCASCADE), Assimp, Alembic, Draco, web-ifc, OpenUSD, OpenVDB, PDAL, OSPRay and ImGui. The 4.0.1 Python wheel reports VTK 9.7.1-1746-gdbb73e9cc8 as its rendering core. File formats are grouped into plugins: native (VTK readers plus glTF, OBJ, STL, PLY, images and Gaussian splats), alembic, assimp (FBX, COLLADA, 3MF and others), draco, hdf, occt (STEP, IGES, BREP, FreeCAD), pdal (lidar), usd, vdb and webifc (IFC). Binary releases load them automatically; distribution packages may split them out.
The quickstart separates full scene formats (glTF/GLB, 3DS, VRML, OBJ, FBX, DAE, OFF, X, 3MF, USD), which carry their own lights, cameras and materials, from geometry-only formats such as STL, PLY or STEP. For the latter F3D builds a default scene with a light grey colour, roughness 0.3, no metalness and a perspective camera.
Engine, scene, window, interactor
An engine is created with a window type; the scene takes files, in-memory meshes or a zero-copy mesh_view; the window renders on screen or to an image; the interactor runs the event loop. Behaviour is driven by named options such as render.grid.enable (98 in the 4.0.1 library), which the CLI flags map onto. Version 4.0 added scene hierarchy, animation and video APIs and statefiles.
Rendering backends
The desktop integration doc states that F3D "supports rendering in environments with limited graphical contexts, including sandboxes or without Xorg running on Linux". The backend is picked automatically, or forced with --rendering-backend: egl and osmesa force headless rendering. F3D loads libEGL.so.1 or libOSMesa.so.8/.6 dynamically, so neither has to exist at install time. The 4.0 changelog adds headless rendering on Windows and macOS as well. The rendering mode is OpenGL by default; OSPRay raytracing and an ANARI mode exist but depend on how VTK was built.
Key features in 4.0
- Broad format coverage: the supported-formats table lists more than 50 formats, from glTF, FBX and USD to STEP, IFC, VTK, DICOM, LAS and Gaussian splats (
.splat,.spz). - Render to file:
--outputwrites a PNG, including to stdout with-, with filename templates such as{model},{date}and{frame}for animation frames;--no-backgroundgives a transparent PNG. - Video output: new in 4.0, writes raw video frames that the docs suggest piping into FFmpeg to get an MP4.
- Rendering effects: SSAO ambient occlusion, neutral tone mapping, FXAA, SSAA and TAA anti-aliasing, depth peeling and other translucency modes, HDRI image-based lighting and skyboxes, matcaps, a grid with optional reflection, edges, normal glyphs and custom final shaders.
- Scientific visualisation: array colouring with colormaps, volume rendering and point sprites.
- Visual regression testing:
--referenceand--reference-thresholdcompare a render against a baseline PNG, and the library exposesimage.compare. - Desktop integration: XDG thumbnailer files on Linux and a shell extension on Windows. The docs state that "F3D does not support thumbnails on macOS".
- Bindings: C, Python (pybind11, with generated stubs), Java 17+ and a WebAssembly build published on npm with an
<f3d-viewer>element.
Getting started
The README points to the download page for packages. Once installed, opening a file is:
f3d /path/to/file.ext
Rendering straight to an image, per the quickstart guide:
f3d /path/to/file.ext --output=/path/to/img.png
Piping, from the options documentation:
f3d - --output=- < path/to/file.glb > path/to/img.png
f3d path/to/file.glb --output-video=- | ffmpeg -f h264 -i - path/to/video.mp4
Offscreen rendering from C++, as shown in the libf3d overview:
// Create a f3d::engine with a offscreen window
f3d::engine eng = f3d::engine::create(true);
// Load a geometry
eng.getScene().add("path/to/file.ext");
// Set the window size and render to an image
f3d::image img = eng.getWindow().setSize(300, 300).renderToImage();
// Save the image to a file
img.save("/path/to/img.png");
The Python example in the language-bindings doc is below, copied as published. Two of its option names fail in 4.0.1, as the hands-on section shows:
import f3d
eng = f3d.Engine.create(False)
eng.options.update({
"model.scivis.array-name": "Normals",
"model.scivis.component": 0,
"ui.bar": True,
"render.grid.enable": True,
})
eng.scene.add("f3d/testing/data/dragon.vtu")
eng.interactor.start()
The web build installs from npm:
npm install f3d
For 3D Gaussian splatting data in .ply, the troubleshooting page recommends these flags:
--point-sprites-size=1 --point-sprites=gaussian --coloring-mode=direct -k
Hands-on: the F3D 4.0.1 Python wheel, headless
Everything in this section ran on 22 November 2026 in a cloud VM: Ubuntu 24.04.5 LTS, Linux 6.18, x86_64, 2 vCPUs, about 7.8 GiB RAM, no swap, Python 3.13.18. There was no GPU and no /dev/dri device, so every frame was rasterised on the CPU by Mesa (25.2.8 for EGL, 25.1.7 for OSMesa). The fps overlay in one render read "4 fps", which sets expectations for every timing below. The f3d.app website was not reachable, so only the repository docs were used. The package was f3d==4.0.1 from PyPI (the cp313 manylinux_2_34 wheel), installed with pip install f3d==4.0.1 into a fresh virtualenv. Test meshes were generated for this page with NumPy and trimesh: a bumpy trefoil-knot surface at exactly 10,000, 100,000 and 1,000,000 triangles, each exported as binary STL, binary PLY, OBJ and GLB. Timings come from time.perf_counter, peak RSS from resource.getrusage, one fresh process per run; ranges show two runs. Single-machine numbers, only indicative.
Install footprint and what the wheel contains
| Check | Result |
|---|---|
| Download | 80,317,906-byte wheel; no Python dependencies (pip list showed only f3d and pip) |
| Installed size | 263 MB virtualenv. libf3d.so alone is 212 MB; libcrypto and libhdf5 are present twice, in f3d/lib64 and f3d.libs |
| Library info | Version 4.0.1, VTK 9.7.1, built 2026-10-31 with GCC 14.2.1, licence BSD-3-Clause; modules FFmpeg, ImGui, OpenEXR and WebP on, Raytracing off |
| Plugins and readers | 8 plugin manifests (native, alembic, assimp, draco, hdf, occt, pdal, webifc), 59 readers. No usd or vdb |
| CLI | No f3d executable is installed. The repository's pyproject.toml sets F3D_BUILD_APPLICATION = "OFF" |
| Startup | import f3d 0.06 to 0.09 s and 94 MiB RSS; plugins plus an offscreen engine add about 0.07 s, giving 192 MiB |
| Video encoders | One: libopenh264 |
Two points matter. First, the wheel has no CLI, so Python users go through the library API (Engine, scene.add, window.render_to_image, Image.save). Second, the plugins page on master has a "Plugin availability per binary" table marking usd and vdb as "Yes" for the Python wheel. In 4.0.1 they are absent: a minimal .usda file was rejected with "does not have an extension corresponding to a supported file format". That table does not exist in the v4.0.1 tag's docs, so it most likely describes a later release. The same goes for the .sog format, --shadows, --offscreen and the xr backend: all are documented on master, but none is in the 4.0.1 wheel or the 4.0.1 tagged docs. The 4.0.1 library has no render.shadows.* options at all.
Rendering backends without a display
Each backend rendered the 100k-triangle GLB at 1280×720. Engine.get_rendering_backend_list() first reported only egl as available. After apt-get install libosmesa6 it also reported osmesa, which confirms the dynamic loading described in the docs.
| How the engine was created | Environment | Result | First / second render |
|---|---|---|---|
Engine.create_egl() | no DISPLAY | Works, EGL window | 0.97 s / 0.78 s |
Engine.create_osmesa() | no DISPLAY, libOSMesa installed | Works, OSMesa window | 1.38 s / 0.97 s |
Engine.create(True) or create(False) | no DISPLAY | Falls back to EGL automatically | 0.78 to 1.33 s / about 0.7 s |
Engine.create(True) or create(False) | under xvfb-run | Picks a GLX window and works | 0.81 to 0.99 s / about 0.77 s |
Engine.create_glx(True) | with or without Xvfb | Fails: "Cannot find libGLX.so library" | n/a |
Engine.create_none() | any | Loads files, but rendering raises "No window with this engine" | n/a |
The practical summary: on a GPU-less Linux box with Mesa's libEGL present, the default create(True) just works, with no Xvfb needed. One inconsistency showed up: under Xvfb the backend list still reported glx: False while create() was using a GLX window, and the explicit create_glx could not find the unversioned libGLX.so even though libGLX.so.0 was installed.
Load and render time by format and size
Default options, 1280×720, EGL, a fresh process per run. "Load" is scene.add(). "First render" is the first render_to_image() and includes GPU-side setup, here done by Mesa on the CPU. "Total" covers everything from import f3d to the saved PNG.
| Mesh | Format (file size) | Load | First / second render | Total | Peak RSS |
|---|---|---|---|---|---|
| 10k triangles | STL (0.5 MB) | 0.004 s | 0.41–0.43 / 0.33 s | 0.90–0.91 s | 319–321 MiB |
| 10k triangles | PLY (0.19 MB) | 0.005 s | 0.63–0.64 / 0.54–0.71 s | 1.29–1.53 s | 318–319 MiB |
| 10k triangles | OBJ (0.35 MB) | 0.015–0.023 s | 0.63–0.66 / 0.55–0.56 s | 1.32–1.40 s | 321–324 MiB |
| 10k triangles | GLB (0.18 MB) | 0.003–0.004 s | 0.71–0.72 / 0.56–0.58 s | 1.41–1.42 s | 324 MiB |
| 100k triangles | STL (5.0 MB) | 0.02 s | 0.81–0.83 / 0.83–0.86 s | 1.82–1.86 s | 333–336 MiB |
| 100k triangles | PLY (1.9 MB) | 0.02–0.03 s | 0.82–1.06 / 0.68–0.90 s | 1.67–2.16 s | 327 MiB |
| 100k triangles | OBJ (3.8 MB) | 0.13–0.23 s | 0.77–0.80 / 0.67–0.68 s | 1.70–1.87 s | 327 MiB |
| 100k triangles | GLB (1.8 MB) | 0.01 s | 0.77–0.78 / 0.70–0.73 s | 1.63–1.66 s | 330–337 MiB |
| 1M triangles | STL (50 MB) | 0.13–0.16 s | 0.93–1.89 / 0.74–0.92 s | 1.97–3.11 s | 542–563 MiB |
| 1M triangles | PLY (19 MB) | 0.17–0.19 s | 0.88–0.94 / 0.75–0.82 s | 2.00–2.10 s | 485–521 MiB |
| 1M triangles | OBJ (41 MB) | 1.31–1.87 s | 1.10–1.20 / 0.85–0.97 s | 3.59–4.09 s | 513 MiB |
| 1M triangles | GLB (18 MB) | 0.07–0.11 s | 1.07–1.29 / 0.81–1.27 s | 2.10–2.85 s | 503–539 MiB |
Parsing is rarely the bottleneck: except for text OBJ at a million triangles, loading took a fraction of the render time, and on this CPU-only machine a 1280×720 frame cost roughly 0.3 to 1.3 s whatever the triangle count. STL has no shared vertices, so the 1M-triangle STL reported 3,000,000 points against 500,000 for the other formats and used the most memory. A million-triangle render peaks at about 0.5 GiB, of which roughly 190 MiB is the library and engine. All twelve PNGs showed the same correctly lit, auto-framed knot.
Rendering options
Options were set with engine.options.update() on the 100k-triangle GLB, one fresh process per row:
| Option(s) | Output | First / second render | Peak RSS |
|---|---|---|---|
| Defaults, 1280×720 | Grey knot, dark background | 0.88 / 0.75 s | 330 MiB |
render.grid.enable | Grid under the model with red and blue axis lines | 0.94 / 0.71 s | 338 MiB |
Grid + render.grid.reflection 0.5 | Grid with a faint reflection of the model | 1.15 / 0.85 s | 344 MiB |
render.effect.ambient_occlusion (SSAO) | Subtle extra shading where the tube crosses itself | 2.87 / 2.49 s | 376 MiB |
render.effect.tone_mapping | A subtle shift in tones | 1.31 / 0.79 s | 352 MiB |
Anti-aliasing fxaa / ssaa / taa | All produced images without errors | 1.11 / 3.74 / 1.22 s first | 339 / 552 / 366 MiB |
render.show_edges | Wireframe over the surface (PNG grew from 167 KB to 638 KB) | 1.25 / 0.87 s | 352 MiB |
| Grid + SSAO + tone mapping + FXAA | Clean product-shot look | 3.03 / 2.53 s | 402 MiB |
render.hdri.ambient (no HDRI file given) | Lit by a built-in default HDRI | 1.48 / 0.85 s | 421 MiB |
HDRI + render.background.skybox "enabled" | Light grey environment background | 1.68 / 1.26 s | 409 MiB |
| Copper colour, metallic 1.0, roughness 0.2, HDRI | Convincing polished-metal reflections | 1.12 / 1.09 s | 383 MiB |
render.effect.display_depth | Greyscale depth image on white | 0.70 / 0.58 s | 316 MiB |
| Orthographic camera + azimuth 45°, elevation 30° | Rotated orthographic view | 0.93 / 0.67 s | 330 MiB |
render_to_image(True) (no background) | RGBA PNG; background pixels (0,0,0,0) | 0.83 / 0.78 s | 333 MiB |
| 256×256 + FXAA (thumbnail) | 38 KB PNG | 0.59 / 0.17 s | 252 MiB |
| 3840×2160, defaults | 704 KB PNG | 5.90 / 5.24 s | 1,236 MiB |
| 3840×2160, grid + SSAO + tone mapping + FXAA | 2.3 MB PNG | 22.6 / 22.7 s | 1,647 MiB |
render.raytracing.enable | Warning "Raytracing options can't be used if F3D has not been built with raytracing"; normal OpenGL image | 0.84 / 0.68 s | 330 MiB |
ui.axis, ui.fps, ui.filename | Axis widget and "4 fps" counter drawn; no filename text appeared | 1.16 / 0.75 s | 346 MiB |
On a software renderer, cost tracks pixels and screen-space effects: SSAA roughly quadrupled render time, SSAO tripled it, and 4K with effects took over 20 s and 1.6 GiB per frame. The options doc warns that TAA "doesn't work with offscreen rendering"; here it raised no error, but its effect was not judged visually. Setting render.background.skybox to True raised a TypeError; the option takes the strings disabled, enabled or blurred. The first HDRI render wrote a 49 MB cache to ~/.cache/f3d, and every load printed a terminal progress bar.
Formats, errors and other API checks
- CAD: a STEP file and a BREP file written with gmsh (a box with a cylindrical hole, plus a sphere) loaded in 0.022 s and 0.006 s and rendered correctly. The STEP produced 2 actors, the BREP 1.
- Sample data:
dragon.vtu(26,532 cells),BoxAnimated.gltfandf3d.glbfrom the repository's LFS test data all rendered. The animation API reported 1 animation, 4 keyframes and a 0 to 3.71 s range. Frames rendered afteranimation.load_time()differed only at some sample times, so frame-accurate export was not verified. - In-memory meshes: building an
f3d.Meshfrom NumPy arrays converted to lists and adding it took 0.07 s for 100k triangles and 0.33 s for 1M; the render matched the file version, and peak RSS was 807 MiB at 1M. - Bytes buffers:
scene.add(bytes)loaded GLB, STL, PLY and OBJ content without a file name. - Batch thumbnails: reusing one engine with
scene.clear(), 256×256 and FXAA, eight 10k and 100k files took 0.147 s each. Adding the four 1M files raised the average to 0.47 s per file, with peak RSS 391 MiB. - Errors are Python
RuntimeErrors with clear messages, such as "contains unsupported content" for random bytes named.stl. - Forcing a reader was uneven.
scene.force_reader = "PLYReader"loaded a PLY renamed to.txt."GLB"on a GLB renamed to.stlfailed with "failed to load scene", and so didscene.skip_content_check."STL"on a corrupt.stlreported "STL is not a valid force reader", although"STL"worked on a valid file. - Documented Python example:
model.scivis.array-nameandui.barraiseKeyErrorin 4.0.1. The working names aremodel.scivis.array_nameandui.scalar_bar, andoptions.get_closest_option()helps find them. - Image comparison:
Image.compare()gave 0.0 for identical renders, 0.005 for plain vs FXAA and 0.082 for plain vs SSAO (the CLI's default threshold is 0.04). - Video:
VideoEncoderwith OpenH264 encoded 60 frames at 640×480 in 5.5 s, andffproberead back a valid H.264 stream of 60 frames.
Second opinion: PyVista on the same meshes
PyVista 0.49.2 (with VTK 9.7.2 and matplotlib from PyPI) rendered the same STL and GLB files with Plotter(off_screen=True) at 1280×720. It also chose a vtkEGLRenderWindow without a display. Its virtualenv was 732 MB, against 263 MB for F3D alone.
| Mesh | F3D 4.0.1 load / first render / RSS | PyVista 0.49.2 read / first screenshot / RSS |
|---|---|---|
| 10k, GLB | 0.004 s / 0.71 s / 324 MiB | 0.04 s / 0.55 s / 409 MiB |
| 100k, STL | 0.02 s / 0.82 s / 335 MiB | 0.09 s / 0.53 s / 418 MiB |
| 1M, STL | 0.13–0.16 s / 0.93–1.89 s / about 550 MiB | 0.58 s / 1.78 s / 652 MiB |
| 1M, GLB | 0.07–0.11 s / 1.07–1.29 s / about 520 MiB | 0.14 s / 2.08 s / 672 MiB |
Both run on VTK, so similar magnitudes are expected; PyVista imported in about 0.35 s warm against under 0.1 s for F3D. The defaults differ more: F3D framed the model to fill the view on a dark background, while PyVista's isometric default left it smaller on white. PyVista suits analysing meshes in NumPy; F3D needs less code for a good-looking image of an arbitrary file.
What could not be tested
- The desktop CLI and thumbnailer: release binaries are on github.com, which was unreachable; CLI details here come from the docs.
- GPU performance: with no GPU, every timing reflects Mesa's software path.
- USD, VDB and raytracing: not in the 4.0.1 wheel.
- FBX, IFC, LAS and Alembic: the readers are present, but no test files were available.
- The WebAssembly viewer: not run in a browser.
Use cases
- Thumbnails and previews in a backend: an upload service for a model library, a PLM tool or a self-hosted Git server can turn STEP, glTF or STL files into PNG previews with the Python wheel and the EGL backend. In this test that cost about 0.15 s per small model when one engine was reused.
- Visual regression tests for 3D output: pipelines that generate geometry, such as a text-to-CAD harness or a slicer like OrcaSlicer exporting 3MF and STL, can render each artifact and diff it against a baseline with
--referenceorImage.compare(). - Turntables and animation clips: camera control plus the video API or
--output-video, with FFmpeg wrapping the raw H.264 stream into MP4. - Quick inspection: FBX, VTU, LAS or IFC files in one viewer.
- Embedding a viewer: libf3d in C++ or Java apps, or the
<f3d-viewer>element where a full three.js scene is overkill.
How F3D compares
Descriptions come from each project's README and licence file as read on 22 November 2026. PyVista was run against the same meshes (see above). The others were not run.
| Project | What its README says it is | Headless image output | Licence |
|---|---|---|---|
| F3D 4.0.1 | "Fast and minimalist 3D viewer" plus libf3d; explicitly no editing, processing or export | CLI --output; library with EGL/OSMesa backends (tested) | BSD-3-Clause |
| PyVista | "A NumPy-native API for 3D visualization and mesh analysis" on top of VTK | Plotter(off_screen=True) (tested) | MIT |
| ParaView | "Open-source, multi-platform data analysis and visualization application based on" VTK | The README mentions OSMesa builds via the superbuild; not tested | BSD-style (Kitware copyright notice) |
| MeshLab / PyMeshLab | "Processing and editing of unstructured large 3D triangular meshes" (cleaning, healing, converting) | Not described in the READMEs read; not tested | GPL-3.0 |
| Blender | "The free and open source 3D creation suite", covering modelling to compositing | Not described in the README; not tested | GPL-3.0 "as a whole" |
| three.js | "JavaScript 3D library" with WebGL and WebGPU renderers | Browser renderers (WebGL, WebGPU); headless output not covered in the README | MIT |
PyVista and ParaView share F3D's VTK foundation: PyVista for mesh analysis in Python, ParaView as a full analysis application. F3D overlaps on scientific formats but also reads DCC and CAD formats (FBX, STEP, IFC, USD in desktop builds) out of the box. MeshLab is the choice when the mesh itself needs repair or conversion, which F3D refuses to do by design. Its GPL-3.0 licence also matters when embedding. Blender can render anything F3D can and far more, but it is a full creation suite under the GPL, which is a lot of tool for producing previews. three.js and engines such as O3DE are for building interactive 3D applications. F3D's web build is narrower: a viewer element for dropping a model onto a page.
Things to know before adopting
- The Python wheel is a library, not the app. No
f3dcommand is installed. Every CLI example in the docs needs the desktop package or your own wrapper around the API. - Docs on
masterrun ahead of the release. Missing from the 4.0.1 library or its tagged docs:--shadowsandrender.shadows.*,--offscreen, thexrbackend, the.sogreader, and theusdandvdbplugins in the wheel, although themasterplugin table says the wheel has them. Pin docs to thev4.0.1tag. - Doc inconsistencies. The 4.0.0 changelog announces "
--video-output", while the options page (onmasterand atv4.0.1) documents--output-video. Which one the binary accepts was not checked. The Python example in the bindings doc uses two option names (model.scivis.array-name,ui.bar) that raiseKeyError. - Size. 263 MB installed and about 190 MiB RSS before loading anything. That is far lighter than PyVista plus VTK in this test (732 MB), but heavy for a minimal container or a serverless function.
- CPU-only rendering is usable but not fast. Expect about 0.3 to 1 s per 720p frame without effects, and tens of seconds for 4K with SSAO. The limitations page notes that "Volume rendering and HDRI support require a decent GPU".
- Format quality varies. The limitations page warns that some Assimp files (FBX, DAE, 3MF and others) "can be empty, crash, or show artifacts", DXF support is very limited, and Alembic has no materials.
- Raytracing is build-dependent. The troubleshooting page states it "is not shipped in the Python wheels". In 4.0.1, the option only prints a warning.
- Side effects on disk. HDRI use wrote a 49 MB cache under
~/.cache/f3d;Engine.cache_pathandwindow.set_use_hdri_cacheare the knobs. Loads also print a progress bar to the terminal. - Breaking changes happen. 4.0 removed deprecated CLI options and VTK 9.3 support and reworked libf3d options; a migration guide covers code written for 3.5.
- Platform notes. Release binaries are unsigned on Windows and macOS (the docs give workarounds), and there are no thumbnails on macOS.
- Contribution policy. The README says F3D "is not a AI friendly project in order to limit maintainer load"; its AI policy requires disclosure and bans AI-generated issues and pull requests.
- When not to use it: when the mesh must be repaired, decimated or converted (use MeshLab or a mesh library); when the deliverable is an interactive web app (use three.js); when the job is analysis of large simulation data with pipelines and filters (ParaView or PyVista); or when an image-size budget rules out a 263 MB dependency.
Project activity
Checked 22 November 2026: latest release v4.0.1, licence BSD-3-Clause. The 4.0.1 wheels on PyPI and the npm package were published on 31 October 2026, eleven days after 4.0.0 reached PyPI on 20 October. The GitHub release itself was published at 13:22 UTC on 31 October 2026, per the GitHub releases API. 4.0.1 fixes a Windows window-placement bug, USD streaming, a crash when the event loop runs before the first render, and missing video header includes. The f3d-app/f3d repository had 5,091 stars and 482 forks at the time of writing. It is written in C++, was created on 17 February 2020, develops on master and was last pushed on 22 November 2026. Documentation lives in the repository's doc/ folder and at f3d.app. A written governance policy makes the owners of the f3d-app GitHub organisation the maintainers, who add or remove maintainers by a two-thirds vote. Sponsors named in the README include NLnet (NGI0 Core) and OpenDroneMap. Third-party code is listed in THIRD_PARTY_LICENSES.md, which the README describes as "all under permissive licenses". PyPI carries 4.0.1 wheels for CPython 3.11 to 3.15, including free-threaded 3.14t and 3.15t builds, for manylinux x86_64, macOS arm64 and Windows.
Enjoying this project?
Discover more amazing open-source projects on TechLogHub. We curate the best developer tools and projects.
Repository:https://github.com/f3d-app/f3d
GitHub - f3d-app/f3d: F3D: Fast, Minimalist 3D Viewer and Rendering Library
F3D is a BSD-3-Clause 3D viewer and C++ library with Python, Java and JS bindings. Version 4.0.1 tested headless on a GPU-less VM: EGL/OSMesa renders, formats u...
github - f3d-app/f3d
Related Projects
Maintain F3D: Fast, Minimalist 3D Viewer and Rendering Library? Add the badge to your README
Show that the project is featured on TechLogHub and send readers to this write-up.
[](https://techloghub.com/open-source/f3d-3d-viewer?utm_source=techloghub_badge&utm_medium=referral&utm_campaign=readme)