Semantic search

Jump to: navigation, search

Edit query Show embed code

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

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

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.
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 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 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 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' 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 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 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 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 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.
"flam3' renders fractal flames as described on 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 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.
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.
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 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' 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.
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 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 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' 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.
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 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 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 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 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.
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' 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' (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 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 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).
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.
'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 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 is a map editor for BSP maps. It can create and edit maps for several games, including Xonotic and OpenArena.
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 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 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.
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:
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
A game engine providing a Lua API to enable developers to create games easily and with few restrictions.
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 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.
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' 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 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 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 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 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 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 converts photos of an object, taken from different angles, into a 3D model
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.
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 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.
## 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 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 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 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 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 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' 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' 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, 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 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 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 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 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 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 lets you build voxel worlds (similar to worlds found in Minetest and Terasology) on the Web.
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.
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
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.
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 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.
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' is a general-purpose replacement for the Athena toolkit which adds a 3D appearance and support for XPM images.
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 (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.