Semantic search

Jump to: navigation, search
Search

Edit query Show embed code

The query [[Graphics::3d]] was answered by the SMWSQLStore3 in 0.0150 seconds.


Results 1 – 107    (Previous 500 | Next 500)   (20 | 50 | 100 | 250 | 500)   (JSON | CSV | RSS | RDF)


3D Pong
A one-or-two player "pong" (ball and paddles) game for X-Window, drawn using vectors (lines). Different view modes are available, including split red/blue mode for using 3D glasses. Two players supported by connecting to multiple X-Window displays.
3dldf Heckert gnu.tiny.png
3DLDF Three-dimensional drawing with MetaPost output. It is written in C++ using CWEB. It is intended, among other things, to provide a convenient way of including 3D graphics in TeX documents. This package includes an interactive program called `3dldf', which implements a language intended to resemble Donald Knuth's METAFONT language and John Hobby's MetaPost language, which is based on METAFONT.
AdaGate
A combination of Portal and Sokoban, AdaGate is a great example of OpenGL programming using the Ada language. It is F.O.S., of course. While exploring a remote south-seas island you make a startling historical discovery. But before you can report your findings, an operational stargate transports you into a curious sequence of dungeons. Your escape will require the logical rearrangement of weird power cells, called Zero Point Modules (ZPMs), that can roll in only two directions. You can shoot your portal guns at the dungeon walls to define a wormhole. But, in order to activate it, all of the ZPMs must be bumped into their sockets. Now, you can only PUSH the ZPMs. That means you will fail if you roll one into a corner or against a wall. Escape each level and find your way back to a beautiful lake on the surface. The degree of difficulty is now selectable. Each game resumes at the beach but progress from previous games is tracked. Complete all 4 levels to access the lake epilog and reset the game. Uses fully modern OpenGL methods in Ada using textures, shaders and uniforms that achieves version 3.3 core profile contexts in a way that is sufficiently mainstream that it easily compiles and runs on Windows, GNU/Linux and Mac OS-X systems. This project serves as a testbed for learning the complexities of modern OpenGL and GLSL. Absolutely no coding efforts or compromises have been made to accomodate proprietary operating systems except for learning how to compile on OS-X. It relies on a thin SDL2 binding from Dan Vazquez, a thin OpenGL binding from "Lumen", a PNG reader by Stephen Sanguine, and SFML-Audio. If one defines "modern" OpenGL to mean version 3.3 or beyond, then this may be the most functionally advanced demonstration of "modern" OpenGL using Ada to be found. The code itself is far from elegant, but serves as a working example, with focus on learning OpenGL. The Ada bindings used are thin, so the relationship to C++ methodology is quite transparent. Developers should note that these Ada bindings are usable as a standalone library for most any OpenGL project. Media Files Note: The particular choices of sound, image, and shader files (*.fs) delivered are not essential to the function of the game and are easily replaced. This software is primarily intended as a tutorial example of modern OpenGL game assembly methods. The only requirements are that sounds be in WAV format, images be in PNG format, and shaders be updated to GLSL 330 specifications.
AdaVenture
AdaVenture is a kid-friendly retro point & click game, essentially intended to be a minimal extension to 3D of the original 2D Atari game named "Adventure". Set in ancient Persia, it begins outside the castle of the young King Xerxes, who inherited a golden chalice from his father, Darius the Great. Coveted by Greek foes King Leonidas of Sparta and King Minos of Crete, the chalice has been stolen. Your quest is to seek and return the royal chalice to its pedestal within the castle of Xerxes...a stealth mission to avoid open hostilities. But, there will be obstacles to overcome. You must find the keys to various realms, defend yourself against dragons and the Minotaur, avoid snakes and pesky bats who steal things only to drop them in random locations, and survive the maze of the green mamba.
Algart
AlgART are free software Java libraries, supporting generalized smart arrays and matrices with elements of any types (1 bit, 8/16/32/64-bit integers, 32/64-bit floating point values and any other Java types), including a wide set of of 2D-, 3D- and multidimensional image processing and other algorithms, working with arrays and matrices.

Main Features

  • The libraries use 63-bit addressing of array elements (all indexes and length are represented by 64-bit long type). So, it's theoretically possible to create and process arrays and matrices containing up to 2^63-1 (~10^19) elements of any primitive or non-primitive types, if OS and hardware can provide necessary amount of memory or disk space.
  • Memory model concept allows storing AlgART arrays in different schemes, from simple Java arrays to mapped disk files; all necessary data transfers are performed automatically while every access to an element or a block of elements.
  • Most of algorithms are based on wide usage of lazy evaluations. Typical operations, like elementwise summing or geometrical matrix transformations, are implemented via lazy views of the source array or matrix.
    • For example, you can take a multidimensional matrix, rotate it (or perform any other affine or projective transform), and then extract a submatrix from the result. All these operations will be performed virtually (not requiring time), and actual calculations will be performed only at the moment of accessing elements, usually while copying the resulting matrix to a newly created one. Moreover, in many cases the libraries will "understand" itself, that the user wants to perform rotation or another transform, and will split the matrix into suitable rectangular blocks (fitting in RAM) and choose the best algorithm for this task at the moment of copying operation.
  • The libraries contain a wide set of image processing algorithms over matrices: linear filtering, mathematical morphology, rank operations, spectral transformation (FFT), etc.
  • There is also skeletonization and measuring of binary images.
Aqsis
Aqsis is a Renderman(tm) compliant 3D rendering toolkit. It is based on the Reyes rendering approach. Features include programmable shading, true displacements, NURBS, CSG, Motion Blur, and direct rendering of subdivision surfaces.
ArtofIllusion
Art of Illusion can be used as a 3D Modeller and can be used to create movies. It can currently import and export Alias .obj files and export VRML97 files (without animation). To create movies, Art of Illusion has a offline renderer and set of tools to create animations. Highlights include subdivision surface based modelling tools, skeleton based animation, and a graphical language for designing procedural textures and materials.
Asymptote
'Asymptote' is a script-based vector graphics language for technical drawing, inspired by MetaPost but with an improved C++-like syntax. It provides for figures the same high-quality level of typesetting that LaTeX does for scientific text. It is a programming language, not just a graphics program, so it can use the best features of both scripts and GUIs. High-level graphics commands are implemented in the language itself, so they can be tailored to specific applications. Labels and equations are typeset with LaTeX for high-quality PostScript output.
Ayam
Ayam is a free 3D modelling environment for the RenderMan interface. Ayam features at a glance:
  • RIB (RenderMan Interface Bytestream) export and import.
  • Support for NURB curves and (trimmed) NURB surfaces, Boxes, Quadrics (Sphere, Disk, Cylinder, Cone, Hyperboloid, Paraboloid, and Torus), CSG, MetaBalls, Polygonal and Subdivision Meshes.
  • NURBS modelling includes normal and interpolating curves as well as extrude, revolve, sweep, skin, gordon, and birail objects with caps, holes, and bevels.
  • Custom objects that may freely implement their representations (using OpenGL and RIB) and even small GUIs to edit their type specific parameters may be written by the user and dynamically loaded at runtime.
  • Scripting interface: Tcl.
  • Miscellaneous: instancing, arbitrary number of modeling views, object clipboard, independent property clipboard, console, n-level undo.
BRL-CAD
BRL-CAD includes an interactive geometry editor, parallel ray-tracing support for rendering and geometric analysis, path-tracing for realistic image synthesis, network distributed framebuffer support, image-processing and signal-processing tools.
Blender
Blender is an integrated 3D suite for modelling, animation, rendering, post-production, interactive creation and playback (games). Blender has its own particular user interface, which is implemented entirely in OpenGL and designed with speed in mind. Python bindings are available for scripting; import/export features for popular file formats like 3D Studio and Wavefront Obj are implemented as scripts by the community. Stills, animations, models for games or other third party engines and interactive content in the form of a standalone binary and/or a web plug-in are common products of Blender use.
CGAL
The goal of the CGAL Project is to provide easy access to efficient and reliable geometric algorithms in the form of a C++ library. CGAL is used in various areas needing geometric computation, such as: computer graphics, scientific visualization, computer aided design and modeling, geographic information systems, molecular biology, medical imaging, robotics and motion planning, mesh generation, numerical methods...
CGAL offers data structures and algorithms like triangulations (2D constrained triangulations and Delaunay triangulations in 2D and 3D), Voronoi diagrams (for 2D and 3D points, 2D additively weighted Voronoi diagrams, and segment Voronoi diagrams), Boolean operations on polygons and polyhedra, arrangements of curves and their applications (2D and 3D envelopes, Minkowski sums) mesh generation (2D Delaunay mesh generation and 3D surface mesh generation, skin surfaces), geometry processing (surface mesh simplification, subdivision and parameterization, as well as estimation of local differential properties, and approximation of ridges and umbilics), alpha shapes, convex hull algorithms (in 2D, 3D and dD), operations on polygons (straight skeleton and offset polygon), search structures (kd trees for nearest neighbor search, and range and segment trees), interpolation (natural neighbor interpolation and placement of streamlines), shape analysis, fitting, and distances (smallest enclosing sphere of points or spheres, smallest enclosing ellipsoid of points, principal component analysis), and kinetic data structures. All these data structures and algorithms operate on geometric objects like points and segments, and perform geometric tests on them. These objects and predicates are regrouped in CGAL Kernels.
CGKit (Python Computer Graphics Kit)
The Python Computer Graphics Kit is a collection of Python modules that contain the basic types and functions to be able to create 3D computer graphics images (focusing on Pixar's RenderMan interface).
Castle Game Engine
Castle Game Engine is a cross-platform 3D and 2D game engine for Object Pascal (FPC and Lazarus). - It supports many formats for game assets, including X3D, VRML, Collada, Spine JSON, MD3 and others. - Many graphic effects are possible, including bump mapping, shadows, shaders, mirrors, screen effects. - Animation, collision detection, 3D sound and more features are available. - An extensible system of 3D objects can be used, with out-of-the-box levels, items, intelligent creatures and more. - The engine is portable -- for desktop, mobile, web plugin. The engine is also used to develop view3dscene - a full-featured X3D / VRML browser and a viewer for many other 3D and 2D game formats.
Cl-ana
cl-ana is a library of modular utilities for reasonably high performance data analysis & visualization using Common Lisp. (Reasonably means I have to be able to use it for analyzing particle accelerator data). The library is made of various sublibraries and is designed in a very bottom-up way so that if you don't care about some feature you don't have to load it. The functionality support so far are
  • Tabular data analysis: Read-write of large datasets stored in HDF5 files are supported, along with ntuple datasets, CSVs, and in-memory data tables. Users can add their own table types by defining 4 methods and extending the table CLOS type.
  • Histograms: Binned data analysis is supported with both contiguous and sparse histogram types; functional interface is provided via map (which allows reduce/fold) and filter.
  • Plotting: Uses gnuplot for plotting dataset samples, plain-old lisp functions, histograms, strings-as-formulae, and anything else the user wishes to add via methods on a couple of generics.
  • Fitting: Uses GSL for non-linear least squares fitting. Uses plain-old lisp functions as the fit functions and can fit against dataset samples, histograms, and whatever the user adds.
  • Generic mathematics: CL doesn't provide extendable math functions, so cl-ana provides these as well as a convenient mechanism (a single function) for using these functions instead of the non-extendable versions. Already included are error propogation and quantities (values with units, e.g. 5 meters) as well as a GNU Octave-style handling of sequences (e.g. (+ (1 2) (3 4)) --> (4 6)).
Coin
Coin is a platform-independent retained-mode 3D graphics library that uses scene-graph data structures to render real-time graphics+suitable for mostly all kinds of scientific and engineering visualization applications. It is fully compatible with Open Inventor 2.1. Coin is built on the OpenGL immediate-mode rendering library, adds abstractions for higher-level primitives, provides 3D interactivity, increases programmer convenience and productivity, and contains optimization features for fast +rendering that are transparent for the application programmer.
Compiz
Compiz is the result of the re-unification of the Beryl-project and the community around the Compiz Window Manager. It seeks to provide an easy and fun-to-use windowing environment, allowing use of the graphics hardware to provide impressive effects, amazing speed and unrivalled usefulness. The first Compiz Fusion developer release was Compiz Fusion 0.5.2 on August 13th 2007.
Compiz Plugins- Extra
This is the Extra plugin package for Compiz.
Compiz Plugins- Main
This is the Main plugin package for Compiz.
Cpsed
'Cpsed' is a OpenGL 3D scene editor. It lets you import .3ds model files and position, rotate and scale each of them. It features open, save, and delete functions. The 3ds loader also loads the textures in JPG/BMP/TGA format. Support for DFF Renderware is planned. The scene file save format is pure ascii with comma separated values.
DrQueue
Drqueue is a distributed rendering queue. It manages jobs on a renderfarm. It supports Maya, Blender, and Bmrt (Renderman) out of the box, and can support any other renderer or computing task that can be handled via scripting. The package has three tools: master, slave and drqman. The master acts as a server where tasks are stored and where computers running slaves report success or failure in executing tasks. The slaves run on every node of the renderfarm. They report load average; if it is below a set level, they are available for rendering and take the first task assigned by the master server. drqman is a GUI for controlling jobs and computers.
Drishti
Drishti stands for vision or insight in Sanskrit, an Indian language. Drishti has been developed keeping in mind the end-use : visualizing tomography data, electron-microscopy data, etc. Understanding the data set is important and conveying that understanding to the research community or a lay person is equally important. Drishti is aiming for both. The central idea about Drishti is that the scientists should be able to use it for exploring volumetric datasets as well as use it in presentations.
EMAN
EMAN is a scientific image processing suite designed mainly to perform single-particle reconstructions of individual molecules. In this method, a transmission electron microscope is used to collect images of thousands of individual molecules. A complex series of algorithms then turns the individual 2D images into a high-resolution 3D structure of the molecule. The core of EMAN is a C++ based scientific image processing library.
Emerald- Compiz Theme Manager
Emerald controls the appearance of your window borders in Compiz. It allows you to install, edit and switch between various themes.
Equalizer
Equalizer is a framework for the development and deployment of parallel OpenGL applications. An Equalizer application can run unmodified on any visualization system, from a singlepipe workstation to large scale graphics clusters and multi-GPU workstations. Equalizer is built upon a scalable OpenGL-based programming interface solving problems that are common to any multipipe application. The API is minimally invasive, making application porting as easy as possible while delivering maximum performance.
Experimental Robotics Framework
The Experimental Robotics Framework is a framework for developing composable applications. The idea is to develop software components that interact with others previously developed in other applications and other components developed by other researchers. It is not a new concept in the field, it is very similar to IBM eclipse but in this case for 3d applications and based on C++ instead of Java.
Flames
"flam3' renders fractal flames as described on http://flam3.com. It is an advanced version of the Gimp plug-in. The package includes flam3-animate, which makes animations; flam3-render, which makes still images; and flam3-genome, which creates and manipulates genomes (parameter sets).
FreeCAD
FreeCAD is an CAx RAD based on OpenCasCade, Qt and Python. It features some key concepts like Macro recording, Workbenches, ability to run as a server and dynamically loadable Application extensions and it is designed to be platform independent.
FreeWRLDI
This is a candidate for deletion: Links broken. No links to page. Email to maintainer broken. Poppy-one (talk) 02:32, 31 July 2018 (EDT) FreeWRLDI (FreeWRLduneInputDevice), together with FreeWRL, lets you "hover" through 3D data in the Web with 4 degree of freedom input devices. It is based on FreeWRL's "/tmp/inpdev" extern sensor input interface and white_dune's input device mechanism.
GTO
The GTO format's primary usage is storage of static geometric data. The types of data you might find in a GTO file are things like polygonal meshes, various types of subdivision surfaces, NURBS or UBS surfaces, coordinate systems, hierarchies of objects, material bindings, and even images. "GTO' is used at Tweak Films to streamline the modeling, animation, rendering, and 3-D paint processes. It includes source code for a Maya plug-in, various command line tools, a Wavefront .obj parser, and a Python module for reading and writing GTO files. There is also an emacs mode gto-mode.el for editing GTO text files.
Geomview
Geomview is interactive geometry software which is particularly appropriate for mathematics research and education. It can display objects in hyperbolic and spherical space as well as Euclidean space. Geomview allows multiple independently controllable objects and cameras. It provides interactive control for motion, appearances (including lighting, shading, and materials), picking on an object, edge or vertex level, snapshots in SGI image file or Renderman RIB format. Adding or deleting objects is provided through direct mouse manipulation, control panels, and keyboard shortcuts. External programs can control certain aspects of viewing (such as continually loading changing geometry or controlling the motion of certain objects) while allowing interactive control of everything else. It can be used as a standalone viewer for static objects or as a display engine for other programs. It can display objects described in a variety of file formats. It comes with a wide selection of example objects, and you can create your own objects too.
Gleem Heckert gnu.tiny.png
Gleem (OpenGL Extremely-Easy-to-use Manipulators) is a library for Java and C++ offering a set of 3D widgets that support direct user interaction with a 3D scene. These widgets are used to translate along a line, translate in a plane, and do three-dimensional translation and rotation.
Glv - OpenGL viewer command line tool
A generic openGL viewer for the prompt. The goal of this project is to make 3d rendering as accessible as text is, with well-known command-line tools (like grep, sed, gnuplot, etc.). The viewer is useable with pipes, and defines a simple input format.
Gmsh
'Gmsh' is an automatic 3D finite element mesh generator with build-in CAD and post-processing facilities. Its design goal is to provide a simple meshing tool for academic test cases with parametric input and up to date visualization capabilities. It can respect a characteristic length field for the generation of adapted meshes on lines, surfaces and volumes, and mix these meshes with simple structured grids. Gmsh is built around four modules: geometry, mesh, solver and post-processing. The specification of any input to these modules is done either interactively using the graphical user interface or in ASCII text files using Gmsh's own scripting language.
Gnu3dkit
GNU 3DKit is an object oriented graphics framework for creating 3D graphics applications in the Objective-C language. The last version (released in 2002) can no longer be downloaded. It has since been decommissioned and is no longer developed. 3DKit was officially part of the GNU project as an extension to GNUstep. Its main application was to render 3D graphics in real-time on commodity hardware, using a scene graph architecture. It was based on OpenGL graphics library to achieve this goal.
Gnubik Heckert gnu.tiny.png
GNUbik is an interactive, graphical, single player game. It renders an image of a Rubik cube and allows you to manipulate it and hopefully solve it. GNUbik supports cubes of any size; 3x3x3 is the default. It also has a guile interface by which you can create your own scripts to solve the cube.
Godot
Godot is a 2D and 3D game engine, featuring:
  • Use your eyes
    • Work inside a simple, yet flexible and feature rich editor, with tools popping up to aid you only when you need them.
  • Develop 2D games
    • Create complex 2D games with the fully dedicated 2D engine (no need for 3D over 2D), using pixel coordinates and a wide array of tools.
  • Develop 3D games
    • Create realistic looking 3D games with the dedicated 3D Engine, with full support for lights, shadows, occlusion, post processing, skeletal animation, etc.
  • Script
    • Add custom behaviors to any object by extending it with scripting, using the built-in editor with syntax highlighting and code completion.
  • Design
    • Create simple or complex user interfaces, or make your own custom tools to edit your game content.
  • Animate
    • Animate your games with full support for editing, blending, animation trees, realtime cutscenes, calling function, or animate just any property exported by any node.
  • Simulate
    • Add physics to your 2D and 3D scenes, through rigid and static bodies, characters, raycasts, vehicles and more.
  • Debug
    • Use the built-in debugger with breakpoints and stepping, or check the performance graphs for possible bottlenecks.
  • Deploy
    • One-click deploy to several platforms, such as GNU/Linux, OS X, Windows, Android, iOS, BB10 and HTML 5.
  • Extend
    • Extend the editor and your game by using plugins, which add extra functionality for both.
  • Work in a team
    • Develop projects in a team using any choice of VCS, as Godot integrates flawlessly with all of them.
Gphoton
Gphoton is a simple 3d modeller with integrated ray tracer. It lets you construct/manipulate/modify a 3d model while approximating the scene with OpenGL. It renders with either the software ray-tracer or OpenGL; screenshots can be saved to TIF. You move around in the scene interactively with keyboard/mouse combinations and/or dialog clicks. It's intended primarily for artistic use (as opposed, for example, to use as a 3D modeller for games). As a ray-tracer entirely implemented in software, the program is extremely slow compared to hardware 3d graphics. However, being software, it is extremely flexible and extensible, more hardware independent, and can produce images of outstanding quality and very high resolutions (ie ANSI-E size 300 dpi images).
Graphics3D
'Graphics3D' is a C++ library for game developers, researchers, and students. It is a base of robust and high performance code common to most 3D projects. It is not a standalone graphics or game engine--it is a set of pieces to jumpstart your own engine or graphics project. The library has two parts: G3D for pure math, and GLG3D for interacting with hardware acceleration via OpenGL. You can use G3D without GLG3D if you want to use another 3D API or don't like the OpenGL abstraction.
Guile-opengl Heckert gnu.tiny.png
Guile-OpenGL is a library providing access to the OpenGL graphics API from Guile.
JFreeChart
A free Java chart library. JFreeChart supports pie charts (2D and 3D), bar charts (horizontal and vertical, regular and stacked), line charts, scatter plots, time series charts, high-low-open-close charts, candlestick plots, Gantt charts, combined plots, thermometers, dials and more. JFreeChart can be used in applications, applets, servlets and JSP. JFreeChart's extensive feature set includes: - a consistent and well-documented API, supporting a wide range of chart types; - a flexible design that is easy to extend, and targets both server-side and client-side applications; - support for many output types, including Swing components, image files (including PNG and JPEG), and vector graphics file formats (including PDF, EPS and SVG); - JFreeChart is free software. It is distributed under the terms of the GNU Lesser General Public Licence (LGPL), which permits use in proprietary applications.
K-3D
K-3D is an advanced 3D modeling, animation, and rendering system that is extremely portable. It is designed from-the-ground-up to generate motion-picture-quality animation using RenderMan, the de facto industry standard for 3D graphics.
K3DSurf
K3DSurf is a program for visualizing and manipulating multidimensional surfaces by using Mathematical equations. It's also a "modeler" for POV-Ray in the area of parametric surfaces. It features 3D, 4D, 5D, and 6D HyperObjects visualization, full support for all functions (like the C language), support for mouse events in the drawing area, animation and morph effects, Povscript and mesh file generation, and support for VRML2 and OBJ files. More than 100 examples are provided.
KiCad
KiCad is electronic design automation (EDA) software made for designing schematics of electronic circuits and printed circuit boards (PCB). KiCad is developed by the KiCad Developers Team, and features an integrated environment with schematic capture, bill of materials list, PCB layout and much more. KiCad is cross-platform, written with WxWidgets and runs on FreeBSD, Linux, Microsoft Windows and Mac OS X. A lot of component libraries are available. Also migrating tools for components are available (from other EDA software tools). File formats are plain text and well documented, which is good for CVS or Subversion and to make automated component generation scripts. Multiple languages are supported, such as English, Portuguese, Spanish, Czech, Polish, French, German, and Russian. The 3D PCB viewer use 3D model from Wings3D CAD.
Lib3ds
Lib3ds is a free library for handling 3DS files. Its goal is to simplify the creation of 3DS import and export filters. It features support for little and big endian CPUs, modules for vector, quaternion, and matrix mathematics, simple data structures which are easy to manipulate, evaluation of all animation data, seamless integration with OpenGL, and the ability to load most 3DS chunks found in the material, camera, light, mesh, and keyframer sections.
LibL3D
L3D is a 3D library for developing OpenGL applications under GNU/Linux. The library has a mail event loop with callbacks and Camera And Path Classes exist to produce cinematic camera movement. FPS entities are under construction.
LibQGLViewer
'libQGLViewer' is an C++ library which lets you quickly start the development of a new 3D application. It is designed for 3D developers, who can display and move around a 3D scene by simply providing the openGL orders that define their 3D geometry. The viewer is designed to be as general as possible and is not designed for a specific 3D application. It provides some useful classical functionalities such as a camera trackball, screenshot saving, mouse manipulated frames, stereo display, keyFrames and more. 'libQGLViewer' is not a 3D viewer that can be used directly to view 3D scenes in various formats; it is more likely to be the starting point for the coding of such a viewer.
LibTAP
'libTAP' (The Architectural Playground) is a prototyping system for virtual reality and augmented reality applications. It runs on a variety of platforms. RAP (rapid application prototyping) is done through the Lua interface, which mirrors the C++ namespace as closely as possible. libTAP has a small but distinctive feature set, focused on prototyping of realtime 3D simulations.
  • Also known as 'Tacitpixel'.
Lightfeather
Lightfeather is a 3D engine for GNU/Linux. It is designed to be easy to use but still take advantage of the features of modern graphics hardware.
Mandelbulber
Mandelbulber is an experimental application that helps to make rendering 3D Mandelbrot fractals much more accessible. A few of the supported 3D fractals: Mandelbulb, Mandelbox, BulbBox, JuliaBulb, Menger Sponge, Quaternion, Trigonometric, Hypercomplex, and Iterated Function Systems. All of these can be combined into infinite variations with the ability to hybridize different formulas together.
Maverik Heckert gnu.tiny.png
Maverik is a development toolkit that supports 3D virtual environments and interaction with those environments. It sits on top of a low-level rendering engine that uses OpenGL or Mesa, and provides mechanisms to render different kinds of objects, to manage environments and to provide support for 3D interaction. The system is open-ended in how its representation of different models. It uses call back functions, rather than importing and converting data to its own formats; this means it can be adapted relatively easily to widely differing application data structures without forcing particular representations on the implementor. For example, if you have a sim in which different parts of your model are varying dynamically but in ways that cannot be represented using the normal affine transformations (eg deformable objects), then Maverik lets you use the dynamically changing data directly to generate images. It also contains support for a variety of 3D input designs, and various kinds of displays (including stereo).
MeshLab
The MeshLab system is aimed to help the processing of the typical not-so-small unstructured 3D triangular models arising in 3D scanning; it provides a set of tools for editing, cleaning, healing, inspecting, rendering and converting this kind of meshes. It support many 3D formats and it is able to load and process large meshes composed by millions of triangles.
MisfitModel3D
'Misfit Model 3D' is an OpenGL-based 3D model editor. It supports multi-level undo, skeletal animations, simple texturing, scripting, command-line batch processing, and a plugin system for adding new model and image filters, and includes complete online help.
Moonlight3D
Moonlight3D is a modeller for 3-dimensional art. It supports Nurbs- and Bezier curve based modelling and many basic shapes (such as Box, Sphere, Cylinder, Plane, Cone and Torus) as well as many texture, material and light parameters, that can be rendered using the inbuilt raytracing-renderer. You can even create objects using Extrusion, Revolution or Skin-, Sweep-, Soft- and BiRail-Surfaces. You can import models using the DXF and 3DS standards, and export to RIB, DXF, VRML, Rayshade, and POV.
NetRadiant
NetRadiant is a map editor for BSP maps. It can create and edit maps for several games, including Xonotic and OpenArena.
Octave-interval
The interval package for real-valued interval arithmetic allows one to evaluate functions over subsets of their domain. All results are verified, because interval computations automatically keep track of any errors. These concepts can be used to handle uncertainties, estimate arithmetic errors and produce reliable results. Also it can be applied to computer-assisted proofs, constraint programming, and verified computing. The implementation is based on interval boundaries represented by binary64 numbers and is conforming to IEEE Std 1788-2015, IEEE standard for interval arithmetic.
OpenGLUT
OpenGLUT is a project to evolve the GLUT (OpenGL Utility Toolkit) C/C++ API. OpenGLUT uses the freeglut code base (from which it split in February 2004) as a foundation for extending, enhancing and refining the API.
OpenSceneGraph Editor
OpenSceneGraph Editor (OSGEdit) is used to compose complex scenes based on individual models using the OSG library. It is focused on making scenes for use in OSG-based programs.
OpenShot
OpenShot can take your videos, photos, and music files and help you create the film you have always dreamed of. Easily add sub-titles, transitions, and effects, and then export your film to many common formats.
OpenStudio
Comprehensive modeling software to analyze energy consumption (e.g., heating and air conditioning demand) in building and other structures. Developed by the Alliance for Sustainable Energy, LLC, operator and manager of the U.S. Dept. of Energy National Renewable Energy Laboratory. Support: https://unmethours.com/questions/
OpenVRML
OpenVRML is a VRML/X3D browser and C++ runtime library. +The library includes parsers for VRML97 and VRML-encoded X3D as well as a +full runtime system for playing VRML/X3D content. An XEmbed control is +included along with frontends for use both as a stand-alone player and as a +Mozilla Gecko Web browser plug-in
Openblox
A game engine providing a Lua API to enable developers to create games easily and with few restrictions.
Openscad
OpenSCAD is a software for creating solid 3D CAD objects. It focuses on CAD aspects rather than artistic ones. OpenSCAD is not an interactive modeller. Instead it is something like a 3D-compiler that reads in a script file that describes the object and renders the 3D model from this script. This gives the designer full control over the modelling process and enables him to easily change any step in the modelling process or make designes that are defined by configurable parameters.
Orthanc
Orthanc aims at providing a simple, yet powerful standalone DICOM server. It is designed to improve the DICOM flows in hospitals and to support research about the automated analysis of medical images. Orthanc can turn any computer running Windows or GNU/Linux into a DICOM store (in other words, a mini-PACS system). Its architecture is lightweight and standalone, meaning that no complex database administration is required, nor the installation of third-party dependencies. What makes Orthanc unique is the fact that it provides a RESTful API. Thanks to this major feature, it is possible to drive Orthanc from any computer language. The DICOM tags of the stored medical images can be downloaded in the JSON file format. Furthermore, standard PNG images can be generated on-the-fly from the DICOM instances by Orthanc. Orthanc lets its users focus on the content of the DICOM files, hiding the complexity of the DICOM format and of the DICOM protocol.
POV-Ray
The Persistence of Vision Raytracer is a high-quality, Free Software tool for creating stunning three-dimensional graphics. The source code is available for those wanting to do their own ports.
Panorama Heckert gnu.tiny.png
'Panorama' includes modeling, rendering, and post-processing; animation support will be added soon. It is structured as an API composed of two dynamic lib and several plug-ins. It currently includes a console mode front end, but a graphical interface is also being developed. Users can use other interfaces, as long as they use the Panorama API or output some scene language that Panorama can read. Plug-in architecture lets you load just the components you need; these components can be substituted or added to without recompiling. This allows for better interaction of modules and makes the program run faster. Several rendering methods (including raytracing and zbuffer) are available without any other change in the input scene file. A post-processing system lets you apply filters to the whole image after it has been generated by the renderer; there are also object filters, which you apply to an object during the rendering process. Material have a BSDF that encapsulates its properties with respect to the light.
Pixie
'pixie' is a RenderMan like photorealistic renderer. It supports all RenderMan 3.2 primitives as well as:
  • Object instancing / delayed primitives
  • Displacements
  • Programmable shading (RenderMan Shading Language)
  • High quality texture/shadow/environment mapping
  • High dynamic range input/output
  • Raytracing
  • Motion blur
  • Depth of field
  • Reyes style rendering (very fast)
  • Occlusion culling
  • Network parallel rendering
  • DSO shaders
  • Global illumination
  • Photon mapping
  • Irradiance caching
  • Automatically raytraced smooth reflections / shadows
PyMOL
PyMOL is a molecular visualization system created by Warren Lyford DeLano and commercialized initially by DeLano Scientific LLC, which was a private software company dedicated to creating useful tools that become universally accessible to scientific and educational communities. It is currently commercialized by Schrödinger, Inc. PyMOL can produce high-quality 3D images of small molecules and biological macromolecules, such as proteins. PyMOL is one of a few free visualization tools available for use in structural biology. The Py portion of the software's name refers to the fact that it extends, and is extensible by the Python programming language. PyMOL uses OpenGL Extension Wrangler Library (GLEW) and Freeglut, and can solve Poisson–Boltzmann equations using the Adaptive Poisson Boltzmann Solver.
PyOpenGL
PyOpenGL is the cross platform Python binding to OpenGL and related APIs. The binding is created using the standard (in Python 2.5 and above) ctypes library. PyOpenGL includes support for OpenGL v1.1 through 3.0, GLU, GLUT v3.7 (and FreeGLUT), and GLE 3. It also includes support for hundreds of OpenGL extensions. PyOpenGL is interoperable with a large number of external GUI libraries for Python including (wxPython, FxPy, PyGame, and Qt). It can be used with the Tkinter GUI library if you have installed the Togl widget for Tk.
Pybik
Pybik is a 3D puzzle game about the cube invented by Ernő Rubik. * Various 3D puzzles, such as cubes, towers, prisms, tetrahedra, octahedra, dodecahedra and many more * Solvers for some puzzles * Pretty patterns * Editor for move sequences * Custom colors and images on the surface of the puzzles
Quat
Quat generates 3d fractal objects. These objects are Julia sets using quaternions. The package can calculate usual images and stereo pair images for real 3d views, and includes a user-specified true color palette for flexible coloring, 5 iteration formulas, and intersection planes so users can cut open a 3D fractal to see its interior. The program calculates fractals in PNG image format using 24bit true color. There is also a text mode version for batch calculation.
ReCaged
ReCaged is a Free Software, Futuristic, Racing Game. With the main inspiration taken from the "Rollcage" and "Rollcage: Stage II" games, it has been written from scratch with focus on high simulation realism and flexibility. It also supports highly detailed 3D models for both rendering and collision detection. The project can also be found on Savannah and TuxFamily.
Regard3D
Regard3D converts photos of an object, taken from different angles, into a 3D model
Reliquarium
Reliquarium is a set of four 3D slider puzzles, all with a Crystal Skull theme. Reckless raiders Jones & Croft have plundered a tomb and displaced an ancient relic. The objective is to return the relic to the center of its cubical box by rearranging the numbered blocks back into their proper order, which usually represents an RGB coloring...Red in the X-direction, Green in the Y-direction, Blue in the Z-direction. Dragging the cursor rotates the cube for a better view angle. The mouse wheel zooms. Typing a number 1..8 selects a block to move, 0 selects the relic itself. Then use the keys {u,d,l,r,f,b} to move it. Alternatively, you can select a block by clicking the cursor near your pick, prior to the move. As indicated on screen, (h) will toggle a help screen. These puzzles are easy enough for children and will likely help with learning 3D visualization, geometry, problem solving and computer skills. Uses the Ada programming language and fully modern OpenGL methods with textures, shaders and uniforms. Focusing on portability and freedom, no coding effort or compromise has been made to accomodate proprietary operating systems. It relies on a thin SDL2 binding from Dan Vazquez, a thin OpenGL binding from "Lumen", a PNG reader by Stephen Sanguine, and SFML-Audio (because of its elegant audio interface). Written in C++ style, the code neglects many safety features available to Ada, but it does serve as a working example for learning OpenGL. The Ada bindings used are thin, so the relationship to C++ methodology is transparent. Developers should note that these Ada bindings are usable as a standalone library for most any OpenGL project that uses Ada. Thus, for the C++ programmer the code should be easy to comprehend; and for the experienced Ada programmer there are many potential improvements to be made. Suggestions or improvements from Ada developers are not only welcomed, but solicited.
RufasCube
This is not another Rubik's Cube; it's a whole new kind of puzzle. A 3³ arrangement of cubelets with the center one missing allows sliding permutations. After a randomization, the goal is to restore the cube to its original configuration based on color and alphabetic hints. Runs on Windows,Linux or MacOSX. This project can help with learning modern OpenGL.
RufasGate
RufasGate is a combination of Portal and Sokoban...While exploring an isolated tropical island, you find an operational stargate that transports you into a curious sequence of dungeons. Finding your way back up to the surface will require ingenuity to solve some 3D sokoban puzzles. The Zero Point Modules [ZPMs] that you find lying around power the portal guns. You can shoot these guns at most walls to create a wormhole, a shortcut through space-time. But, in order to empower the portal guns, all cylindrical ZPMs must be bumped onto their base receptacles. Not easy! Note that you can only PUSH the ZPMs. That means you can fail if you roll one into a corner or against a wall. Transcend each level and make your way back up to the cool night air on the surface. There are currently 4 levels; now each game resumes at the level attained in the previous game. Note that the ZPM shape is the intersection of two cylinders, which means they roll in only two perpendicular directions. Uses fully modern OpenGL methods in C++ using shaders and uniforms. Media Files Note: The particular choices of sound, image, and shader files (*.fs) delivered are not essential to the function of the game and are easily replaced. This software is primarily intended as a tutorial example of modern OpenGL game assembly methods. The only requirements are that sounds be in WAV format, images be in PNG format, and shaders be updated to GLSL 330 specifications. Skybox images have an additional constraint, they must also have a 90x90 degree field of view [for a correct perspective], and all 6 must have the same pixel size.
RufasSeven
## Seven Game Introduction Seven is NOT another Rubic's Cube. It's a whole new kind of puzzle. A 2x2x2 arrangement of cubelets with one missing allows sliding permutations. After a randomization, the goal is to restore the cube to its original configuration based on color and numeric hints. Dragging the cursor rotates the cube for a better view angle. Clicking the cursor on a cubelet adjacent to the empty space will slide it into that empty space. On laptops you may also hit <return> when the cursor is on the cubelet of choice to select and slide it. On MacBooks, a 2-finger tap on the touchpad does the job. As indicated on screen, <h> will toggle a help screen, and <c> will toggle color schemes. Works on Macs running OS-X and PCs running GNU/Linux.

Uses the Ada programming language and fully modern OpenGL methods with textures, shaders and uniforms. Achieves version 3.3 core profile contexts, and compiles and runs on both GNU/Linux and Mac OS-X systems. This project serves as a testbed for learning the complexities of modern OpenGL and GLSL.

Focusing on portability and freedom, no coding effort or compromise has been made to accomodate proprietary operating systems. It relies on a thin SDL2 binding from Dan Vazquez, a thin OpenGL binding from "Lumen", a PNG reader by Stephen Sanguine, and SFML-Audio (because of its elegant audio interface).

The Ada bindings used are thin, so the relationship to C++ methodology is quite transparent. Developers should note that these Ada bindings are usable as a standalone library for most any OpenGL project that uses Ada.
SDL gfx
SDL_gfx is a library that contains graphics primitives and surface functions for SDL2. Current components of the library are:
  • Graphic Primitives
  • Surface Rotozoomer
  • Framerate control
  • MMX image filters
  • Build-in 8x8 Font
They are wrapped up in an addon library which is also under the Zlib license.
SPlotter3D
SPlotter3D lets you plot any 2D or 3D parametric function, save and open parameters of a plot, and print or export to PostScript format. Features include separate output and control windows to allow more working space, and zoom and axis control. Many samples are included for reference.
SharpConstruct
SharpConstruct is a 3D modeling program that paint depths on to polygon models in real-time. Unlike traditional modeling programs, SharpConstruct makes it easy to model organic shapes. There is no need to even look at a wireframe (unless you want to). Instead, the model is manipulated much like clay, push or pull an area, smooth it, make a hollow or a hill. The entire process is both simple and organic; you won't need years of modeling experience to create detailed models in SharpConstruct. This project is no longer maintained.
Simple CCSM- CompizConfig Settings Manager
This is the configuration tool for Compiz.
Sly
Sly is a free software game engine written in GNU Guile Scheme. It provides an abstraction layer above SDL and OpenGL for common game programming requirements such as meshes, shaders, sprites, animation, tilesets, scene graph, keyboard/mouse input, and scripting. Sly differentiates itself from other game engines by providing an interactive development environment via Guile's read-eval-print-loop (REPL), exposing a functional API instead of an object-oriented one, and encouraging reactive programming.
SolveSpace
SolveSpace is a parametric 2D and 3D CAD program. Applications include: modeling 2d and 3d parts, and export DXF, PDF, SVG, 3d printing, preparing CAM data, simulate planar or spatial linkages, plane and solid geometry.
Soya
Soya 3D is a very high level 3D engine for Python. Soya aims at being to 3D what Python is to programming : fast to learn, easy to use, while keeping good performances ! Soya is Free Software, under the GNU GPL. Soya's goal #1 is to allow to develop as rapidly as possible 3D games and other 3D apps. Soya's goal #2 is to be as easy as possible to learn. In particular, Soya is used in the games Slune and Balazar Brother.
Stl2pov
'stl2pov' reads an STL (Standard Triangulation Language) file and outputs a POVray mesh. It creates either triangles by default, but can generate smooth_trianges; can read binary STL files, and has an option to smooth the generated mesh.
Stopmotion
'Stopmotion' is a free application for creating stop-motion animation movies. Users will be able to create stop-motions from pictures imported from a camera or from the harddrive, add sound effects, and export the animation to different video formats such as mpeg or avi.
SuperTuxKart
SuperTuxKart, also known as STK, is a 3D kart racing game. There is also a site dedicated to STK add-ons.
Sweet Home 3D
Sweet Home 3D is a free interior design application that helps you to quickly draw the floor plan of your house, arrange furniture on it, and visit the results in 3D. It lets you:
  • Draw walls and rooms upon the image of an existing plan, on one or more levels
  • Drag and drop doors, windows and furniture from a catalog onto the plan
  • Update colors, texture, size and orientation of furniture, walls, floors and ceilings
  • View all changes simultaneously in the 3D view from any view point
  • Create photorealistic images and videos with various light sources
  • Import additional 3D models and export the plan at various standard formats
Three.js
Three.js is a JavaScript 3D library, designed to make usage of WebGL simpler.
Torque 3D
Torque 3D is a 3D game engine with advanced graphics.
Trigger Rally
The 3D rally game features an open landscape with no boundaries. Simple greyscale elevation maps form the terrain and road. Sprites are added as vegetation and road maps. Key feature is the good physics for drifting. But keeping on the road is not as easy as in many other rally games. Precise handling is paramount in order to keep the cars on track. Fog, different weather and light conditions add variation. To win a race you need to reach checkpoints in a certain order and get to the last one before the time limit is reached. In addition to many single race maps there are events where you need to win several races in a specific order in order to win the whole event. Since version 0.6.4 there is a career mode where additional maps and cars can be unlocked. There are already 170 races available. It's quite easy to add new maps and to adjust parameters. This game doesn't need the newest hardware. You can easily play it with quite old systems. Only basic 3D-support is needed.
True3DShell
True3DShell is a 3D desktop environment with functionality similar to KDE or GNOME. Information is organized in "bubbles" connected by "pipes". A bubble can be the equivalent of a folder in a computer, a shared folder in a network, or an execution space for a 3D program. <>"Bubbles" generated by different computers are connected "pipes" acting as network connections, providing network transparency. Users and automated avatars interact in the same 3D universe, browsing or running 3D programs locally or remotely without regard to physical location.
Tulip
Tulip is a software system for visualizing huge graphs. It manages graphs with up to 500,000 elements (node and edges) on a personal computer (PIII 600, 256MB RAM). Its SuperGraph technology architecture provides the following features: 3D visualizations, 3D modifications, plugin support, support for clusters and navigation, automatic graph drawing, automatic clustering of graphs, automatic selection of elements, and automatic coloring of elements according to a metric.
VNet
VNet uses Java to turn a single-user VRML world into a Multi-user Online Virtual Environment System (MOVES), complete with avatars and chat. A normal Web browser with a normal VRML plugin is all you need to experience a 3D social space. VNet is based on JDK 1.02 to ensure portability and in development is a version based on JDK 1.1.x that adds user persistence, scalability, and other features. It has both client and server packages.
View3dscene
view3dscene is a viewer for many 3D model formats: - X3D - VRML (1.0 and 2.0, aka VRML 97 - Collada - OpenInventor - 3DS - MD3 - Wavefront OBJ - Videoscape GEO - castle-anim-frames (Castle Game Engine animations) - STL Various navigation modes are available, like Examine, Walk (with gravity), Fly. Collision detection is done. Models can be animated and interactive. Many graphic effects are possible, thanks to using Castle Game Engine underneath. view3dscene may also be used to convert many 3D model formats to X3D (in classic and XML encoding). This package includes also a command-line tovrmlx3d program, that performs the same conversions as view3dscene, but doesn't use X or OpenGL (so it's nice to use in scripts to convert 3D models in batch mode).
Voxel.js
Voxel.js lets you build voxel worlds (similar to worlds found in Minetest and Terasology) on the Web.
Vreng
VREng (Virtual Reality Engine) is a C++ and OpenGL API-based interactive distributed Web3D application for navigating in and interacting with virtual environments over the Internet through their avatars, chat, audio/video channels, shared white-boards and document publishing. It uses XML to describe VR environments, and supports object manipulation and persistence, new multimedia and models types, and built in image and motion capture. It run on *nix platforms using X11 throught the Ubit toolkit.
White dune
'white_dune' is a graphical editor, a simple NURBS/Superformula/Subdivision 3D modeller, and a animation tool for the VRML97(Virtual Reality Modelling Language)/X3D, which is the ISO standard for displaying 3D data over the web via browser plugins (or webgl via X3DOM or X_ITE javascript) . It supports animation, realtime interaction and multimedia (image, movie, sound). Dune reads VRML97/X3D files, displays, and let the user change scenegraphs/fields. 'white_dune' can also translate a VRML97/X3D file to C, C++ or java. The resulting file can be rendered with OpenGL/jogl. Under GNU/Linux white_dune is a immersive VRML editor. It has support for stereoscopic view via "quadbuffer" capable stereo visuals and support for various 3D input devices supported by the X11 XInput or Linux joystick interface.
Wings3D
Wings 3D is a simple to use but very powerful free and open source polygon mesh modeller inspired by Nendo from Nichimen/Izware. It can import Nendo (.ndo), 3D Studio (.3ds) and Wavefront (.obj) Files. It can export Nendo (.ndo), 3D Studio (.3ds), Wavefront (.obj), RenderMan (.rib) and VRML97 (.wrl) Files
Wings3d
Wings 3D is an advanced subdivision modeler that is both powerful and easy to use. Wings 3D offers a wide range of modeling tools, a customizable interface, support for lights and materials, and a built-in AutoUV mapping facility. There is no support in Wings for animation.
WorldCupSokerban
This is a soccer-themed, 3D sokoban puzzle game. It uses data in a format that is found on the internet. It has undo (u) and restart (r) functions. Comes with dozens of puzzle files, each typically having dozens of "levels". The next (n) and previous (p) keys move between levels. To move the "kicker" use the arrow keys. The objective is to kick all the red and blue balls into the goal nets. Full C++ source code and executable binaries for Windows, GNU/Linux and MacOSX included.
X ITE
X_ITE is a new WebGL X3D Browser engine entirely written in JavaScript and uses WebGL for 3D rendering. Authors can publish X3D source online within an HTML5 page with X_ITE that works with Web browsers without prior plugin installation. This gives X3D authors the ability to displays content in 3D, using WebGL 3D graphics technology to display X3D content in several different browsers across several different operating systems. Since X3D is backwardly compatible, X_ITE can also be used as a VRML viewer.
X3dom
Integrate 3D content seamlessly into your webpage - the scene is directly written into the HTML markup. No Plugins needed.
Xaos Heckert gnu.tiny.png
XaoS is a graphical program that generates fractal patterns and allows you to zoom in and out of them infinitely in a fluid, continuous manner. It also includes tutorials that help to explain how fractals are built. It can generate many different fractal types such as the Mandelbrot set. Various coloring modes are provided for both the points inside and outside the selected set. In addition, switching between Julia and Mandelbrot fractal types and displaying planes is provided. The first version written by Thomas Marsh was a simple Mandelbrot viewer, later modified by Jan Hubicka to support high frame-rate zooming. Other additions were later made including autopilot, palette changing, PNG saving, and fractal inversion, making GNU XaoS a fast portable real-time interactive fractal zoomer.
Xaw3d
'Xaw3d' is a general-purpose replacement for the Athena toolkit which adds a 3D appearance and support for XPM images.
YafaRay
YafaRay is a raytracing render engine. Raytracing is a rendering technique for generating realistic images by tracing the path of light through a 3D scene. An render engine consists of a "faceless" computer program that interacts with a host 3D application to provide very specific raytracing capabilties "on demand".
Zoe
ZOE (formerly OGLE) is an OpenGL graphics engine, written entirely in Python. It's primary focus is rapid prototyping and experimentation, so it only supports the barest essentials, with focus on wire frames. Special emphasis is placed on particle systems (where non-interacting particles follow simple rules). Some familiarity with OpenGL is expected, although when exploiting the particle system abstractions no specific OpenGL knowledge is required. Demos included are the obligatory spinning polyhedra, static views of conic sections and the Solar System, a 3D surface plotter, a fountain of sparks, a swarming behavior model, a random walk example, a whirpool effect using gravity and drag, and an example of chaos theory and sensitivity to initial conditions.


Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the page “GNU Free Documentation License”.

The copyright and license notices on this page only apply to the text on this page. Any software or copyright-licenses or other similar notices described in this text has its own copyright notice and license, which can usually be found in the distribution or license text itself.