solvespace

Parametric 2d/3d CAD

3,364

506

3,364

291

View on GitHub

Top Related Projects

kicad-source-mirror

2,109

This is an active mirror of the KiCad development branch, which is hosted at GitLab (updated every time something is pushed). Pull requests on GitHub are not accepted or watched.

openscad

7,782

OpenSCAD - The Programmers Solid 3D CAD Modeller

LibreCAD is a cross-platform 2D CAD program written in C++17. It can read DXF/DWG files and can write DXF/PDF/SVG files. It supports point/line/circle/ellipse/parabola/spline primitives. The user interface is highly customizable, and has dozens of translations.

qcad

1,583

QCAD - The Open Source 2D CAD. QCAD is a cross-platform CAD solution for Windows, macOS and Linux. It supports the DXF format and optionally the DWG format (through a proprietary plugin).

Quick Overview

SolveSpace is an open-source parametric 2D/3D CAD (Computer-Aided Design) program. It allows users to create precise models for 3D printing, laser cutting, or machining, and can also be used for mechanism design and constraint-based geometry solving.

Pros

Free and open-source
Lightweight and fast, with low system requirements
Powerful constraint solver for parametric modeling
Cross-platform compatibility (Windows, Linux, macOS)

Cons

Steeper learning curve compared to some commercial CAD software
Limited advanced features compared to high-end CAD programs
Smaller user community and fewer resources compared to popular CAD software
Interface may feel dated to users of modern CAD applications

Getting Started

To get started with SolveSpace:

Download the latest release from the official GitHub repository.
Install the software following the instructions for your operating system.
Launch SolveSpace and start a new project.
Familiarize yourself with the interface and basic tools using the official documentation.
Begin creating your first 2D sketch or 3D model using constraints and parameters.

Note: SolveSpace is primarily a GUI application, so there are no code examples to provide. Users interact with the software through its graphical interface rather than writing code.

Competitor Comparisons

kicad-source-mirror

2,109

This is an active mirror of the KiCad development branch, which is hosted at GitLab (updated every time something is pushed). Pull requests on GitHub are not accepted or watched.

Pros of KiCad

More comprehensive EDA suite with PCB design capabilities
Larger community and more frequent updates
Extensive library of components and footprints

Cons of KiCad

Steeper learning curve due to its complexity
Heavier resource usage, potentially slower on older hardware
Less focused on mechanical design aspects

Code Comparison

KiCad (C++):

void PCB_EDIT_FRAME::OnUpdateLayerPair( wxUpdateUIEvent& aEvent )
{
    LSET mask = GetBoard()->GetEnabledLayers();
    bool enable = ( mask & LSET::AllCuMask() ).any();
    aEvent.Enable( enable );
}

SolveSpace (C++):

void SolveSpace::SS::GenerateAll(SS::GenerateAllowedBits allowedToGenerate,
                                 bool andFindFree)
{
    Group::GenerateAll(allowedToGenerate, andFindFree);
    if(allowedToGenerate & GENERATE_ENTITIES) {
        GenerateDisplayItems();
    }
}

KiCad focuses on PCB-specific functionality, while SolveSpace deals with geometric constraints and 3D modeling. KiCad's codebase is larger and more complex, reflecting its broader feature set. SolveSpace's code is more focused on parametric modeling and constraint solving.

openscad

7,782

OpenSCAD - The Programmers Solid 3D CAD Modeller

Pros of OpenSCAD

Text-based parametric modeling allows for version control and easy sharing
Powerful scripting capabilities for complex designs
Large community and extensive library of user-contributed models

Cons of OpenSCAD

Steeper learning curve for non-programmers
Limited interactive modeling capabilities
Slower rendering for complex designs compared to SolveSpace

Code Comparison

OpenSCAD:

module cube_with_hole(size, hole_radius) {
    difference() {
        cube(size, center=true);
        cylinder(h=size+1, r=hole_radius, center=true);
    }
}
cube_with_hole(10, 2);

SolveSpace:

Entity *cube = SK.GetEntity(SS.GW.AddBox(10, 10, 10));
Entity *cylinder = SK.GetEntity(SS.GW.AddCylinder(2, 11));
SS.GW.GroupSelection();
SS.GW.ScreenSelectEntity(cube);
SS.GW.ScreenSelectEntity(cylinder);
SS.GW.MenuRequest(GraphicsWindow::MNU_GROUP_DIFFERENCE);

Both OpenSCAD and SolveSpace are powerful CAD tools with different approaches to 3D modeling. OpenSCAD excels in parametric design through scripting, while SolveSpace offers a more traditional CAD interface with constraint-based modeling. The choice between them depends on the user's preferences and specific project requirements.

LibreCAD

4,816

Pros of LibreCAD

More extensive 2D drafting features and tools
Larger and more active community, resulting in frequent updates and support
Better compatibility with industry-standard file formats (DXF, DWG)

Cons of LibreCAD

Limited to 2D drafting, lacking 3D modeling capabilities
Steeper learning curve for beginners compared to SolveSpace
Heavier resource usage, potentially slower on older hardware

Code Comparison

LibreCAD (C++):

RS_Line* line = new RS_Line(container,
                            RS_LineData(RS_Vector(10.0, 10.0),
                                        RS_Vector(20.0, 20.0)));
container->addEntity(line);

SolveSpace (C):

hRequest = SK.GetRequest(MakeRequest(ENTITY_LINE_SEGMENT));
SK.GetEntity(hRequest.entity(0))->PointA = Vector::From(10, 10, 0);
SK.GetEntity(hRequest.entity(0))->PointB = Vector::From(20, 20, 0);

Both examples demonstrate creating a line, but LibreCAD uses a more object-oriented approach, while SolveSpace employs a procedural style with its own entity management system.

qcad

1,583

QCAD - The Open Source 2D CAD. QCAD is a cross-platform CAD solution for Windows, macOS and Linux. It supports the DXF format and optionally the DWG format (through a proprietary plugin).

Pros of QCAD

More extensive 2D CAD features and tools
Larger user community and better documentation
Supports DXF/DWG file formats natively

Cons of QCAD

Primarily focused on 2D drafting, limited 3D capabilities
Commercial product with a paid version (though open-source edition available)
Steeper learning curve for beginners

Code Comparison

QCAD (C++):

RS_Line* line = new RS_Line(container,
                            RS_LineData(RS_Vector(0.0,0.0),
                                        RS_Vector(10.0,10.0)));
container->addEntity(line);

SolveSpace (C++):

Entity *l = SK.entity.AddLine(workplane, 
                              Vector::From(0, 0, 0), 
                              Vector::From(10, 10, 0));

Both examples demonstrate creating a line entity, but QCAD uses a more object-oriented approach with separate data structures, while SolveSpace has a more compact syntax. QCAD's code reflects its focus on 2D drafting, whereas SolveSpace's code hints at its 3D capabilities with the workplane parameter.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

SolveSpace

This repository contains the source code of SolveSpace, a parametric 2d/3d CAD tool.

Community

The official SolveSpace website has tutorials, reference manual and a forum; there is also an official IRC channel #solvespace at web.libera.chat.

Installation

Via Official Packages

Official release packages for macOS (>=10.6 64-bit) and Windows (>=Vista 32-bit) are available via GitHub releases. These packages are automatically built by the SolveSpace maintainers for each stable release.

Via Flathub

Official releases can be installed as a Flatpak from Flathub.

Get SolveSpace from Flathub

These should work on any Linux distribution that supports Flatpak.

Via Snap Store

Official releases can be installed from the stable channel.

Builds from master are automatically released to the edge channel in the Snap Store. Those packages contain the latest improvements, but receive less testing than release builds.

Or install from a terminal:

# for the latest stable release:
snap install solvespace

# for the bleeding edge builds from master:
snap install solvespace --edge

Via automated edge builds

:warning: Edge builds might be unstable or contain severe bugs! They are intended for experienced users to test new features or verify bugfixes.

Cutting edge builds from the latest master commit are available as zip archives from the following links:

Extract the downloaded archive and install or execute the contained file as is appropriate for your platform.

Via source code

Irrespective of the OS used, before building, check out the project and the necessary submodules:

git clone https://github.com/solvespace/solvespace
cd solvespace
git submodule update --init

You will need git. See the platform specific instructions below to install it.

Building on Linux

Building for Linux

You will need the usual build tools, CMake, zlib, libpng, cairo, freetype. To build the GUI, you will need fontconfig, gtkmm 3.0 (version 3.16 or later), pangomm 1.4, OpenGL and OpenGL GLU, and optionally, the Space Navigator client library. On a Debian derivative (e.g. Ubuntu) these can be installed with:

sudo apt install git build-essential cmake zlib1g-dev libpng-dev \
            libcairo2-dev libfreetype6-dev libjson-c-dev \
            libfontconfig1-dev libgtkmm-3.0-dev libpangomm-1.4-dev \
            libgl-dev libglu-dev libspnav-dev

On a RedHat derivative (e.g. Fedora) the dependencies can be installed with:

sudo dnf install git gcc-c++ cmake zlib-devel libpng-devel \
            cairo-devel freetype-devel json-c-devel \
            fontconfig-devel gtkmm30-devel pangomm-devel \
            mesa-libGL-devel mesa-libGLU-devel libspnav-devel

Before building, check out the project and the necessary submodules.

After that, build SolveSpace as following:

mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release -DENABLE_OPENMP=ON
make

# Optionally
sudo make install

Link Time Optimization is supported by adding -DENABLE_LTO=ON to cmake at the expense of longer build time.

The graphical interface is built as build/bin/solvespace, and the command-line interface is built as build/bin/solvespace-cli. It is possible to build only the command-line interface by passing the -DENABLE_GUI=OFF flag to the cmake invocation.

Building for Windows

Ubuntu will require 20.04 or above. Cross-compiling with WSL is also confirmed to work.

You will need the usual build tools, CMake, and a Windows cross-compiler. On a Debian derivative (e.g. Ubuntu) these can be installed with:

apt-get install git build-essential cmake mingw-w64

Before building, check out the project and the necessary submodules.

Build 64-bit SolveSpace with the following:

mkdir build
cd build
cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/Toolchain-mingw64.cmake \
            -DCMAKE_BUILD_TYPE=Release
make

The graphical interface is built as build/bin/solvespace.exe, and the command-line interface is built as build/bin/solvespace-cli.exe.

Space Navigator support will not be available.

Building for web (very experimental)

Please note that this port contains many critical bugs and unimplemented core functions.

You will need the usual build tools, cmake and Emscripten. On a Debian derivative (e.g. Ubuntu) dependencies other than Emscripten can be installed with:

apt-get install git build-essential cmake

First, install and prepare emsdk:

git clone https://github.com/emscripten-core/emsdk
cd emsdk
./emsdk install latest
./emsdk activate latest
source ./emsdk_env.sh
cd ..

Before building, check out the project and the necessary submodules.

After that, build SolveSpace as following:

mkdir build
cd build
emcmake cmake .. -DCMAKE_BUILD_TYPE=Release -DENABLE_LTO="ON" -DENABLE_TESTS="OFF" -DENABLE_CLI="OFF" -DENABLE_COVERAGE="OFF"
make

The graphical interface is built as multiple files in the build/bin directory with names starting with solvespace. It can be run locally with emrun build/bin/solvespace.html.

The command-line interface is not available.

Building on macOS

You will need git, XCode tools, CMake and libomp. Git, CMake and libomp can be installed via Homebrew:

brew install git cmake libomp

XCode has to be installed via AppStore or the Apple website; it requires a free Apple ID.

Before building, check out the project and the necessary submodules.

After that, build SolveSpace as following:

mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release -DENABLE_OPENMP=ON
make

Link Time Optimization is supported by adding -DENABLE_LTO=ON to cmake at the expense of longer build time.

Alternatively, generate an XCode project, open it, and build the "Release" scheme:

mkdir build
cd build
cmake .. -G Xcode

The application is built in build/bin/SolveSpace.app, the graphical interface executable is build/bin/SolveSpace.app/Contents/MacOS/SolveSpace, and the command-line interface executable is build/bin/SolveSpace.app/Contents/MacOS/solvespace-cli.

Building on OpenBSD

You will need git, cmake, libexecinfo, libpng, gtk3mm and pangomm. These can be installed from the ports tree:

pkg_add -U git cmake libexecinfo png json-c gtk3mm pangomm

Before building, check out the project and the necessary submodules.

After that, build SolveSpace as following:

mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make
sudo make install

Unfortunately, on OpenBSD, the produced executables are not filesystem location independent and must be installed before use. By default, the graphical interface is installed to /usr/local/bin/solvespace, and the command-line interface is built as /usr/local/bin/solvespace-cli. It is possible to build only the command-line interface by passing the -DENABLE_GUI=OFF flag to the cmake invocation.

Building on Windows

You will need git, cmake and a C++ compiler (either Visual C++ or MinGW). If using Visual C++, Visual Studio 2015 or later is required. If gawk is in your path be sure it is a proper Windows port that can handle CL LF line endings. If not CMake may fail in libpng due to some awk scripts - issue #1228.

Before building, check out the project and the necessary submodules.

Building with Visual Studio IDE

Create a directory build in the source tree and point cmake-gui to the source tree and that directory. Press "Configure" and "Generate", then open build\solvespace.sln with Visual C++ and build it.

Building with Visual Studio in a command prompt

First, ensure that git and cl (the Visual C++ compiler driver) are in your %PATH%; the latter is usually done by invoking vcvarsall.bat from your Visual Studio install. Then, run the following in cmd or PowerShell:

mkdir build
cd build
cmake .. -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release
nmake

Building with MinGW

It is also possible to build SolveSpace using MinGW, though Space Navigator support will be disabled.

First, ensure that git and gcc are in your $PATH. Then, run the following in bash:

mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make

Contributing

See the guide for contributors for the best way to file issues, contribute code, and debug SolveSpace.

License

SolveSpace is distributed under the terms of the GPL v3 or later.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot