Curv: a language for making art using mathematics

Created by Doug Moen <[email protected]>

Curv is a programming language for creating art using mathematics. It's a powerful 2D and 3D F-Rep implicit geometric modelling tool that supports full colour, animation and 3D printing.

Features:

• Curv is a simple, powerful, dynamically typed, pure functional programming language.
• Curv is easy to use for beginners. It has a standard library of predefined geometric shapes, plus operators for transforming and combining shapes. These can be plugged together like Lego to make 2D and 3D models.
• Coloured shapes are represented using Function Representation (F-Rep). They can be infinitely detailed, infinitely large, and any shape or colour pattern that can be described using mathematics can be represented exactly.
• Curv exposes the full power of F-Rep programming to experts. The standard geometry library is written entirely in Curv. Many of the demos seen on shadertoy.com can be reproduced in Curv, using shorter, simpler programs. Experts can package techniques used on shadertoy as high level operations for use by beginners.
• Rendering is GPU accelerated. Curv programs are compiled into fragment shaders which are executed on the GPU.
• Curv can export meshes to STL, OBJ and X3D files for 3D printing. The X3D format supports full colour 3D printing (on Shapeways.com, at least). These meshes are defect free: watertight, manifold, with no self intersections, degenerate triangles, or flipped triangles.

Current status

Curv is currently maintained by Tim Ayres (3DLirious). Work is primarily focused on library and tool development, such as:

• lib.tpms - library of 27+ Triply Periodic Minimal Surface lattices. Go beyond the gyroid!
• lib.blend - library of 14+ blending kernels, with colour mixing!
• lib.shapes2d - library of additional 2D shape primatives, including quadratic bezier curves.
• lib.shapes3d - library of additional 3D shape primatives.
• lib.lattice2d - library of 2D infinite lattices, including hexagonal, rhombic, triagonal and rectangular.
• lib.lattice3d - library of 3D beam/strut lattices.
• lib.surfaces - library of interesting implicit surfaces, including Taubin's heart.
• lib.cmap - library of 110+ pre-defined colour maps and utilities to create them.
• lib.util - library of helpful utility functions, such bbox/viewport manipulation, show_ruler & show_grid to measure shapes.
• curvimages.py - Python script to enhance output options. Export as still or animated GIF, APNG, or WEBP image formats with transparency, trace to an SVG vector image, or slice a 3D shape or mesh into layered STL, OBJ, PLY, OFF or X3D mesh formats for 3D printing.
• Oklab and Oklch perceptually uniform colour space support.

...and more. See the TODO list for planned features and improvements.

Getting Started

• For the full experience, build and install the software on Linux or Windows, see BUILD.md (see WINDOWS.md for building natively on Windows using MSYS2).
• For editor syntax highlighting, on Linux there is curv.lang for the gedit text editor, and on Windows there is a Notepad++ UDL file (also in the UDL Collection).
• The documentation is here: docs/README.rst.
• To contribute, see CONTRIBUTING.md.
• Be sure to check out the Cheat Sheet for a handy reference to the Curv language.

Community

• Discord channel (under CodeCad): https://discord.gg/hS3P6w7x.
• Chat room on matrix: Join Matrix Room (or View in Element Web)
• This earlier Discord channel has a ton of interesting discussion history but is now inactive: https://discord.gg/ZSPXaMNWfW.
• There is an old Github Discussions page: https://github.com/curv3d/curv/discussions.
• There is a low-volume mailing list: [email protected], connected to a web forum: https://groups.google.com/d/forum/curv. You can join the mailing list using your Google account (or you'll be prompted to create an account).

Hardware and OS Requirements

Linux and Windows (native & WSL) are supported.

MacOS is not currently supported since there is no one to support it and we have no way of testing changes. See issue #272 if you would like to try compiling Curv on MacOS.

In order to export meshes (STL files, etc) using the fast -Ojit method, you need to have a C++ compiler installed (GCC or Clang), and you need the glm C++ math library installed. These things will already be installed if you have built Curv from scratch using the build instructions. Otherwise, if you are using a prebuilt binary, you may want to install these things. Either way, see BUILD.md.

Curv mostly uses OpenGL 3.3, however features from later versions up to and including OpenGL 4.6 are planned to be added over time. The recommended configuration is a GPU made by Intel, AMD or Nvidia, using a known working GPU driver (see below).

• On Linux, the GPU needs to be modern enough to be supported by the latest driver version from the GPU vendor. Any GPU from 2012 or later will work. Some older GPUs may work: check the list of supported hardware for the driver.
• On Windows, you can use MSYS2 to build and run a native executable; see WINDOWS.md. Alternatively, you can use Windows Subystem for Linux (WSL) for building and running a Linux executable.
• On Linux, you have 3 choices (note: some of the info below may be outdated, updates welcome!):

  • An Nvidia GPU, with the Nvidia closed source driver. Any GPU supported by the latest Nvidia driver will work with Curv.

    The open source Nouveau driver is not supported; it is too slow and buggy. Curv runs too slow, with visual glitches. See issue #78.

  • An Intel GPU, using the Intel supplied open source driver (based on Mesa). Any GPU supported by the latest Intel driver will work with Curv (this means: Intel HD Graphics or later).

  • An AMD GPU with the open source Mesa driver, version 19.x or later. The AMDGPU-PRO (closed source) driver should work, but I have no testing reports for it.

    Mesa version 18.x or earlier has a bug on AMD (issue #30) which prevents some Curv programs from running.

• Raspberry Pi isn't supported.Raspberry Pi 3 and earlier will never be supported, as the GPU is not powerful enough.
• If Curv is invoked within a VNC session, then it might not have direct access to GPU hardware (a slow software renderer is used instead of the GPU). Curv requires a GPU accelerated VNC server. Try TurboVNC combined with VirtualGL.
• If Curv is run inside a VM, then it might not have direct access to the GPU. You need to ensure that the VM is GPU accelerated.
• You can run Curv from the command line on a headless Linux server, to export images and meshes. For image export, you may need to configure a dummy X server: see https://github.com/curv3d/curv/discussions/131.

Curv is not as GPU intensive as AAA video games. Integrated graphics will work fine for most stuff. But you can definitely write Curv code that will benefit from expensive discrete graphics.

Why is Curv so picky about GPU drivers and hardware, when [some old 3D software] runs just fine? The answer is that old 3D software relies primarily on triangle meshes for representing and rendering 3D shapes, whereas Curv uses signed distance fields to represent shapes. Signed distance fields are a powerful, hot new technology that is only made practical by modern GPUs. Curv uses shader programs to render shapes, and uses larger and more complex shader programs than [some old 3D software]. This places a heavy and atypical load on the GPU driver and hardware, which old hardware and old, outdated driver software may not be prepared to deal with.