F3D: Fast, Minimalist 3D Viewer and Rendering Library
GitHub Repo
BSD-3-Clause
November 22, 2026 at 02:29 PM
0 views

F3D: Fast, Minimalist 3D Viewer and Rendering Library

@f3d-appProject Author

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: --output writes a PNG, including to stdout with -, with filename templates such as {model}, {date} and {frame} for animation frames; --no-background gives 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: --reference and --reference-threshold compare a render against a baseline PNG, and the library exposes image.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

CheckResult
Download80,317,906-byte wheel; no Python dependencies (pip list showed only f3d and pip)
Installed size263 MB virtualenv. libf3d.so alone is 212 MB; libcrypto and libhdf5 are present twice, in f3d/lib64 and f3d.libs
Library infoVersion 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 readers8 plugin manifests (native, alembic, assimp, draco, hdf, occt, pdal, webifc), 59 readers. No usd or vdb
CLINo f3d executable is installed. The repository's pyproject.toml sets F3D_BUILD_APPLICATION = "OFF"
Startupimport 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 encodersOne: 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 createdEnvironmentResultFirst / second render
Engine.create_egl()no DISPLAYWorks, EGL window0.97 s / 0.78 s
Engine.create_osmesa()no DISPLAY, libOSMesa installedWorks, OSMesa window1.38 s / 0.97 s
Engine.create(True) or create(False)no DISPLAYFalls back to EGL automatically0.78 to 1.33 s / about 0.7 s
Engine.create(True) or create(False)under xvfb-runPicks a GLX window and works0.81 to 0.99 s / about 0.77 s
Engine.create_glx(True)with or without XvfbFails: "Cannot find libGLX.so library"n/a
Engine.create_none()anyLoads 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.

MeshFormat (file size)LoadFirst / second renderTotalPeak RSS
10k trianglesSTL (0.5 MB)0.004 s0.41–0.43 / 0.33 s0.90–0.91 s319–321 MiB
10k trianglesPLY (0.19 MB)0.005 s0.63–0.64 / 0.54–0.71 s1.29–1.53 s318–319 MiB
10k trianglesOBJ (0.35 MB)0.015–0.023 s0.63–0.66 / 0.55–0.56 s1.32–1.40 s321–324 MiB
10k trianglesGLB (0.18 MB)0.003–0.004 s0.71–0.72 / 0.56–0.58 s1.41–1.42 s324 MiB
100k trianglesSTL (5.0 MB)0.02 s0.81–0.83 / 0.83–0.86 s1.82–1.86 s333–336 MiB
100k trianglesPLY (1.9 MB)0.02–0.03 s0.82–1.06 / 0.68–0.90 s1.67–2.16 s327 MiB
100k trianglesOBJ (3.8 MB)0.13–0.23 s0.77–0.80 / 0.67–0.68 s1.70–1.87 s327 MiB
100k trianglesGLB (1.8 MB)0.01 s0.77–0.78 / 0.70–0.73 s1.63–1.66 s330–337 MiB
1M trianglesSTL (50 MB)0.13–0.16 s0.93–1.89 / 0.74–0.92 s1.97–3.11 s542–563 MiB
1M trianglesPLY (19 MB)0.17–0.19 s0.88–0.94 / 0.75–0.82 s2.00–2.10 s485–521 MiB
1M trianglesOBJ (41 MB)1.31–1.87 s1.10–1.20 / 0.85–0.97 s3.59–4.09 s513 MiB
1M trianglesGLB (18 MB)0.07–0.11 s1.07–1.29 / 0.81–1.27 s2.10–2.85 s503–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)OutputFirst / second renderPeak RSS
Defaults, 1280×720Grey knot, dark background0.88 / 0.75 s330 MiB
render.grid.enableGrid under the model with red and blue axis lines0.94 / 0.71 s338 MiB
Grid + render.grid.reflection 0.5Grid with a faint reflection of the model1.15 / 0.85 s344 MiB
render.effect.ambient_occlusion (SSAO)Subtle extra shading where the tube crosses itself2.87 / 2.49 s376 MiB
render.effect.tone_mappingA subtle shift in tones1.31 / 0.79 s352 MiB
Anti-aliasing fxaa / ssaa / taaAll produced images without errors1.11 / 3.74 / 1.22 s first339 / 552 / 366 MiB
render.show_edgesWireframe over the surface (PNG grew from 167 KB to 638 KB)1.25 / 0.87 s352 MiB
Grid + SSAO + tone mapping + FXAAClean product-shot look3.03 / 2.53 s402 MiB
render.hdri.ambient (no HDRI file given)Lit by a built-in default HDRI1.48 / 0.85 s421 MiB
HDRI + render.background.skybox "enabled"Light grey environment background1.68 / 1.26 s409 MiB
Copper colour, metallic 1.0, roughness 0.2, HDRIConvincing polished-metal reflections1.12 / 1.09 s383 MiB
render.effect.display_depthGreyscale depth image on white0.70 / 0.58 s316 MiB
Orthographic camera + azimuth 45°, elevation 30°Rotated orthographic view0.93 / 0.67 s330 MiB
render_to_image(True) (no background)RGBA PNG; background pixels (0,0,0,0)0.83 / 0.78 s333 MiB
256×256 + FXAA (thumbnail)38 KB PNG0.59 / 0.17 s252 MiB
3840×2160, defaults704 KB PNG5.90 / 5.24 s1,236 MiB
3840×2160, grid + SSAO + tone mapping + FXAA2.3 MB PNG22.6 / 22.7 s1,647 MiB
render.raytracing.enableWarning "Raytracing options can't be used if F3D has not been built with raytracing"; normal OpenGL image0.84 / 0.68 s330 MiB
ui.axis, ui.fps, ui.filenameAxis widget and "4 fps" counter drawn; no filename text appeared1.16 / 0.75 s346 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.gltf and f3d.glb from 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 after animation.load_time() differed only at some sample times, so frame-accurate export was not verified.
  • In-memory meshes: building an f3d.Mesh from 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 .stl failed with "failed to load scene", and so did scene.skip_content_check. "STL" on a corrupt .stl reported "STL is not a valid force reader", although "STL" worked on a valid file.
  • Documented Python example: model.scivis.array-name and ui.bar raise KeyError in 4.0.1. The working names are model.scivis.array_name and ui.scalar_bar, and options.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: VideoEncoder with OpenH264 encoded 60 frames at 640×480 in 5.5 s, and ffprobe read 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.

MeshF3D 4.0.1 load / first render / RSSPyVista 0.49.2 read / first screenshot / RSS
10k, GLB0.004 s / 0.71 s / 324 MiB0.04 s / 0.55 s / 409 MiB
100k, STL0.02 s / 0.82 s / 335 MiB0.09 s / 0.53 s / 418 MiB
1M, STL0.13–0.16 s / 0.93–1.89 s / about 550 MiB0.58 s / 1.78 s / 652 MiB
1M, GLB0.07–0.11 s / 1.07–1.29 s / about 520 MiB0.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 --reference or Image.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.

ProjectWhat its README says it isHeadless image outputLicence
F3D 4.0.1"Fast and minimalist 3D viewer" plus libf3d; explicitly no editing, processing or exportCLI --output; library with EGL/OSMesa backends (tested)BSD-3-Clause
PyVista"A NumPy-native API for 3D visualization and mesh analysis" on top of VTKPlotter(off_screen=True) (tested)MIT
ParaView"Open-source, multi-platform data analysis and visualization application based on" VTKThe README mentions OSMesa builds via the superbuild; not testedBSD-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 testedGPL-3.0
Blender"The free and open source 3D creation suite", covering modelling to compositingNot described in the README; not testedGPL-3.0 "as a whole"
three.js"JavaScript 3D library" with WebGL and WebGPU renderersBrowser renderers (WebGL, WebGPU); headless output not covered in the READMEMIT

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 f3d command is installed. Every CLI example in the docs needs the desktop package or your own wrapper around the API.
  • Docs on master run ahead of the release. Missing from the 4.0.1 library or its tagged docs: --shadows and render.shadows.*, --offscreen, the xr backend, the .sog reader, and the usd and vdb plugins in the wheel, although the master plugin table says the wheel has them. Pin docs to the v4.0.1 tag.
  • Doc inconsistencies. The 4.0.0 changelog announces "--video-output", while the options page (on master and at v4.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 raise KeyError.
  • 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_path and window.set_use_hdri_cache are 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.

Project
f3d-3d-viewer
Created
November 22
Last Updated
November 22, 2026 at 02:29 PM

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.

Featured on TechLogHub
[![Featured on TechLogHub](https://techloghub.com/badge-neutral.svg)](https://techloghub.com/open-source/f3d-3d-viewer?utm_source=techloghub_badge&utm_medium=referral&utm_campaign=readme)

Find more projects like this

One email a week: new and trending developer tools, fresh comparisons, and what shipped. Unsubscribe in one click.