Carrots

Small web apps are perfect for (tabletop gaming) tools

Fri, 12 Jun 2026 13:00:00 GMT

In the last few months, I have created two web apps, mostly for my own needs. These are tiny tools, they did not take a lot of time to build and polish, but I get a lot of value out of them. I guess they can benefit anyone who plays tabletop games regularly.

First, I made MoiMoiMoi. I never use the “last player to have seen an elephant starts” rules. I always find them a bit silly. MoiMoiMoi solves that problem. The gist is that each player puts a finger on the screen, and the app chooses one randomly. Note that this is a Chwazi clone. The original was not working on my phone, although it looks like they recently released a new version that might fix it.

Then I needed a score tracker, Scores. I really like Scorekeeper XL. I valued its simplicity and fun UI, but I had a couple of issues with it. First, there was no way to switch between groups of people. I have different gaming groups (not that many!) but having to re-enter everyone’s names is a bit annoying. Also, some games, like Flip 7, need you to add tens of points at once, which Scorekeeper is not great at either.

These tools do not need accounts, and they do not need much data. In the case of Scores, there is a little bit of data: the groups, as well as the current sheet. The tradeoff is clear to me: either build a full account system, with logins, passwords, sync, complexity, and cost, or ask people to recreate a tiny bit of data on another device. For this kind of tool, I much prefer the second option.

Keeping everything local also means they can work completely offline. If you add them as web apps (still weirdly difficult to find on iOS) they can work fully offline.

I have iterated on them to make the experience feel as smooth as possible. They are definitely not native apps, but using them should feel like using an application, not a clunky web thing. Here again, the platforms do not always make it easy, but it can be done. For instance, Scores can keep the screen on while you use it.

The web has other great benefits:

It is cross-platform: you can use web apps on iOS, Android, or anything that can run a browser.
There is no gatekeeper: no need to have someone review your app before it is available, easy updates, and no need to create special assets for a store.
They are cheap to host. These are static web apps: they consist of a small HTML and JavaScript bundle that can be served for almost nothing.

If you have a small itch to scratch, just build it as a web app, polish it until you are happy with the result, and publish it. It costs almost nothing, and it may help people around you. There is no need to build a business (or try to monetize it). Just share!

The current landscape of 2D CAD libraries

Thu, 09 Mar 2023 08:00:00 GMT

I built the general workflow of replicad to be similar to a standard CAD workflow: draw in 2D, sketch this in a plane in 3D, and then give it some thickness (extrude, revolve or sweep).

Unfortunately, there is no support for some basic 2D CAD operations in open cascade. For instance, there is no 2D boolean operations: fusing shapes together, cutting one with another.

I found multiple libraries to do 2D operations, but they all failed to be the CAD library I expected. Let’s see what they lack (in my opinion, of course), and build my list of requirements.

Solvespace and offsets

We can start with the other open source CAD kernel, solvespace. It is a full featured kernel, but lack an important feature for 2D CAD, offsets.

Offsets can be understood as parallel curves. They tend to be very useful to transform a line into a 2D shape (by giving it some kind of stroke width). CAM tools also use these to draw tool paths.

Clipper and polygons

Then let’s have a look at Clipper. This is a very performant library that does boolean operation (i.e. what they call clipping) and offsetting. Unfortunately, it only works with polygons (i.e. shapes built with straight lines).

What is this issue with polygons? Depending on your use case polygons are great. You can approximate any curve by a set of lines, and then use clipper to do your operations on it. This is what this great gear generator does.

This is the analogous of a mesh for 3D objects. The trade off is also the same – you gain some simplicity of computation (and performance), but lose information about the shape itself (the topology). It becomes more difficult to select an edge of your shape (what is an edge then?).

Note that many other libraries that deal with 2D geometries have the same issue. I could find shapely for instance.

Cavalier contours and a CAD data structure

Cavalier contours is a rust library for offsets and boolean operations that supports arcs of circle in addition to straight lines. It seems that it is based on well researched algorithms, is fast and has some nice webassembly builds.

The issue I have with it, is its data model. As a very well focussed library and offers a simple API for defining poly lines. But it stops at that point – its data structure does not support anything like translations or rotations. There is no concept of holes within closed poly lines and ways to understand the inclusion logic.

I am looking for a full CAD library. Cavalier contours is not that. It is good at some singular operations - but I would need to be extended a lot to become a proper CAD library.

Flatten, maker.js and Bézier curves

Flatten offers all the functionality that clippers and cavalier contours are missing. It supports arcs, is meant as a CAD library, with a data model for “islands” and “holes” and APIs around inclusion of shapes within other shapes.

But arcs are not enough – if you want to draw shapes that are slightly organic or need to be smooth, it becomes useful to offer Bézier curves. For instance fonts for text rendering are represented as sets of Bézier curves. This is also a significant part of paths in SVG (or vector graphics in general).

It is possible to approximate Bézier curves with arcs - but we get the same issue that we had with polygons. You loose the semantic relation between what an edge is and how you represent it.

maker.js (that I used to build the paper models in deckinabox) has the same issue. It is a full CAD library, it let you define Bézier curves, but they are just arcs in disguise.

Note that cavalier contours does not support Bézier either.

Additional considerations

There are some other typical features of 2D CAD software that I did not mention. For instance, performance is not my main concern now - I am more looking for functionality first (and then, potentially, performance).

Then, solvespace, while it does not have offsets, offers a constraints solver. This is very powerful for visual CAD (where these are more intuitive than raw numbers). I have focussed on the code CAD aspects of a 2D library – and I don’t think that constraints are great for code. Note that open cascade also has a constraints solver.

What did I choose for replicad?

Within replicad I use open cascade as the kernel. As I mentioned earlier 2D support within open cascade is sparse.

While it does not offer the CAD operations themselves in 2D (not 2D booleans or offsets), it gives the primitives needed (intersections and offsets of a single curve). So I built the complex curves data structures, boolean operations and offsets on top of the open cascade primitives.

This is still not great. A big drawback is that you need to pull a lot of things from open cascade and deal with garbage collection yourself. It is also far from perfect in many ways. For instance offsets of Béziers tend to fail a lot.

But it has other advantages that none of the other libraries provide. Open cascade has an arc of ellipses type of curve, it provides ways to work with BSplines (even better than Béziers!), it supports stretching and shearing transformations and it has built-in approximation routines.

TL;DR: my list of features

So what do I want from a 2D CAD library:

basic geometric transformations (translations, rotations)
boolean operations
offsets of chains of curves
complex types of curves (arcs, ellipses, Béziers)
data structures thought for CAD with ways to express containment

And there are some other aspects that would be nice to have:

performance
approximation routines
a constraints solver
all affine transformations
BSplines as a type of curve

Even with my minimal requirements I could not find any library that fit the bill. Within replicad, the best I could achieve was to extend open cascade so that it worked with its basic 2D primitives.

You can discuss this post on Mastondon

Bling My Thing - decorate your 3D models

Fri, 01 Apr 2022 12:00:00 GMT

Deckinabox received some feedback asking for ways to decorate easily the boxes. Typically adding a logo, or a little bit of text. I like the Unix philosophy of small tools with a single purpose - making simple boxes is the purpose of that tool, not decoration.

So I created another tool! Bling My Thing is a web application that lets you decorate 3D models. It takes a STEP file (there is also some STL support) and allows you to select faces and apply decorations.

You can add text, make honeycomb or grid pattern and also apply SVGs.

With the help of replicad creating such single purpose web apps for 3D modelling becomes easy. I have open sourced the code, so that anyone can copy the structure of the app and create their own tool.

You can discuss it on Mastodon or Twitter

Make custom storage solutions with deckinabox

Thu, 17 Feb 2022 10:00:00 GMT

Two years ago I bought myself a Silhouette Cameo. I built some nice papercraft statues with it and then went to my old love. Boxes.

So I created deckinabox, an online tool to create boxes and trays.

Models for folding paper or cardstock

Originally it could only generate boxes for card decks, but I fairly quickly extended it to support token trays. With it I make storage solutions for many of my board games, for instance Agricola, 7 Wonders Duel or Paper Tales.

No need to draw, align or think about the maths to build your box. You specify its size, some additional configuration (what kind of lock mechanism do you want?). That’s it.

If you are building a tray, it exposes a simple interface to choose where your separators go. And then it exports multiple formats that makes it available to people with different machines, or even to cut by hand.

The trays and boxes made with cardboard are sturdy (sturdier than what I expected to be honest). They are easy to build, even if for complex trays it can be relatively time intensive.

Models for 3D printing

I wanted to expand this approach of offering a similar tool for models for 3D printing. Usually STL models are built for one purpose only (with small variations). Or can be parametrised with numeral, or if you can, changes in the code.

But I wanted to offer a way to create a model with a custom interface and complex options. I needed to learn a lot of things about 3D modelling and how to build 3D modelling software, but now deckinabox can also generate quick draw decks and token trays models for 3D printing.

It uses the same type of interface as the models for folding paper. Standard card sizes options for decks and separators for the token tray generator.

CodeCAD is great

I am quite proud to be able to offer a solution that allow someone who is not interested in 3D modelling a way to create personalised models for their need.

I could build this tool around a community of people working on codeCAD tools. CodeCAD is this (small?) movement around using code to draw.

If you are interested, have a look at maker.js (that I use for the 2D paper models) and my own replicad for everything 3D!

You can discuss this on Mastodon

Stack homemade cardboard boxes

Wed, 14 Jul 2021 14:00:00 GMT

There is a shelf at my place that is not very practical to store anything but big items. I wanted to create a storage solution to keep my small(-ish) craft tools.

First I needed to create the boxes themselves. This is fairly easy using this nice tutorial video (the third method, starting around minute 48).

This methods requires to cut the bevels at 45 degrees. The good news is that someone already designed the tool for that purpose (and you can download it here).

Unfortunately cardboard boxes are not that easy to stack, especially because I was not that precise measuring and cutting them. So I designed small corners to be able to stack them.

These print quickly, with my standard 0.2mm layer height it is about 15 minutes a piece. It should also work without issue for higher height and faster prints.

Here you can configure and download the files for your own builds.

I made this an editable model, where you can customise:

the cardboard thickness (cardboardThickness). You might add half a millimeter to allow for a bit of tolerance.
the size of the corner (length). This value will be used in both direction
how tall the corner will be (height). Note that the total height will be twice this parameter plus a wallThickness.
how much material you will use to build the structure (wallThickness)

While tweaking the parameters, you might see a blob appear - it means that your configuration made something break.

You can export your file as STL and use a standard configuration for your slicer. The corners are designed to be printed without any support. I print them in groups of 4, with a small brim (5 lines) to avoid them falling over.

You can discuss this on Mastodon or on Reddit

3D printed parts for a baby gym arch

Thu, 24 Jun 2021 15:00:00 GMT

Somehow a baby appeared in my life. I wanted to build him one of these arches where you can suspend toys for him to play with. I think it is called a baby arch.

This arch is built of 4 legs made of rectangular lumber, a wooden rod for the arch itself, and some 3D printed parts for the feet and to connect everything together (I call them the heads).

Here you can configure and download the files to 3D print.

I made this an editable model, where you can customise:

the shape of the (rectangular) legs (legsWidth, legsDepth), as well as how they related to each other (legsAngle)
the radius of the rod (rodRadius)
how much of the legs is covered by the 3D printed piece (footHoleLength and headHoleLength)
more technical parameters (wallThickness and tolerance)

While tweaking the parameters, you might see a blob appear - it means that your configuration made something break.

You can export your file as STL and use a standard configuration for your slicer. Personally I printed them on the flat side, I did not use any support, with layers at 0.2 (and in PLA). I had to clean a bit the legs holes because of an imperfect bridge - but your printer is probably better configured than mine!

You can discuss this on Mastodon or on Reddit

How I create papercraft statues (using my Silhouette Cameo)

Thu, 20 Feb 2020 09:00:00 GMT

You might have seen these papercarfts, low poly, statues or animals floating around the web. I actually bought a nice giraffe trophy, and then wondered if I could do it myself.

This baby yoda is my first project made by myself, and it is fairly easy to do (if you buy the right tools).

First step: the 3D model

You need to start with a 3D model, there are three different ways to can create one (that I have looked into):

find a low poly statue
find a high poly statue and lower the resolution
scan an object in the world and lower the resolution
build yourself a 3D model

For all the methods you will need a editor for 3D objects. Personally I played with Blender, as it is good (and free).

Finding a low poly statue

Online you can find free (or paying) 3D models. I go on the thingiverse or cadnav for instance. You can find there some low poly models.

For the next step you will need to have them in .obj format. You can use Blender to do the conversion. The steps are the following:

open a new project
remove the default cube (select it and then press X)
import from .stl (which is the standard format for the objects I found so far
export as .obj

Lowering the resolution of a high poly statue

For high poly statues the steps are very similar than for low poly, you will need to lower the resolution. For which Blender has the right tool as well.

Once your model is loaded into your scene in Blender, select all the points and use the decimate function. Lower the ratio until you reach a number of polygons that seem good for you. This answer can help you as well.

Scanning a real world object

This is something that I have not tried (yet). But I figured out that with recent phones it should be possible to scan a real world object. For instance this app for iOS seems nice.

Buiding the model yourself from scratch

Finally you can go deep with Blender and learn to build yourself a 3D model. Obviously this is a world into itself and you will need to learn how to use these tools. As I said, I personally played with Blender and there are lots of nice tutorials out there.

Second Step: Making it flat

Once we have a 3D object, we need to flatten it. This part will need you to buy a little bit of software. There is a functionality withing Blender to do it – but I was not convinced by it.

As I am a Mac user, I tried (and then bought) Unfolder. In this app you can load an .obj file and it will make chunks that are flat. You can then modify them, cut in some places and group others.

I advice you to spend quite some time in there to think of how the different tricky parts will be separated. I am not great at it yet, and figuring out ways to make my life easier afterwards. Typically it seems to be better to have cuts along long edges - it makes the pasting better.

You can also look at the 3D render to separate the pieces with different colors (and use multiple papers of different color).

Do not forget to enable numbers for flap, use the auto functionality to optimise the flap sizes and organise the different parts.

To prepare for the next step we will export into 2 formats: .dxf for the cuts and .png for the print. You can also export a .pdf if you want to do the cutting by hand.

Note that there is an equivalent software for Windows (that seems uglier but with more features, pepakura

Third Step: cutting

First, if you do not have a cutting machine and do not want to invest more money in this project you can print the pdf and then cut by hand. Depending on the project there can be lots of cuts to make.

I bought myself a Silhouette Cameo 4. This will make this step way faster.

In the silhouette studio software import the .png file (it contains all the numbers, as well as the marks for folding. You can now import the .dxf file and make sure both overlay perfectly.

Add the alignment marks and then print on the paper of the color you are interested in. I used 160mg paper - it worked fine for my projects. Note that with dark color papers you might want to strengthen the black alignment marks with a marker.

Once you have the paper printed, we can actually use the silhouette machine. In the send menu you will select the different lines. Do a first pass for the scoring marks. You will select only the (blue and green I think) lines for a first pass as scoring - it should not go though the paper, only make it easier to fold in the right place.

Then cut the pieces (the red lines).

Fourth Step: folding and pasting

You now have a bunch of paper cuts. Go though them and fold according to the lines. Note that for the ‘valley’ folds, start folding them the other way and then the right way, it will be easier.

The whole pasting can take time, but I really enjoy the activity, it feels quite zen.

You can discuss this on Mastodon

My wishlist for the web

Thu, 25 Apr 2019 06:00:00 GMT

The web is amazing. But it could be better.

To put a context, I currently would like to see the web as a full software platform, that competes with Windows or iOS in terms of what you could do with the technologies of the web. So what do I want?

More stylable builtin components

Let’s start with something small.

Right now, it is not possible to style the checkmark part of a checkbox on the web. You can create your own and hack something together, sure. But you have to be very careful not to break things. This should not be the case. There should be a supported way to do it.

More importantly, while selects (and datalists) can be styled, the menu that shows when you open it cannot. There are great alternatives to the native components (for instance react-select), but they cannot be as good a native one for all the cases (and require an important open source effort to maintain).

So let us use the builtins by giving us more access to what they look.

A standardised Popper.js

I really like popper.js. It allows me to build tooltips and other menus without sweating too much. This is something that should also be part of the platform. Placing an object in relationship to another is a common interface use case. By offering a native solution we could have this work better and faster across the web.

Native virtual lists (think infinite scroll)

Long lists of items, loaded dynamically. This is the core of most mobile apps. But we need to reinvent them all the time on the web. And this is far from something obvious to implement with many edge cases (and also, difficult to make performant).

Operator overloading for JavaScript

Now this is a bit different, a pure javascript need. Operator overloading is the language feature in javascript that I miss the most from python. Why?. Guido wrote an great article about why operators are important.

I would add that this feature is what is missing for a good scientific community on javascript. This is what is missing for a nodejs sqlalchemy.

People are already working on it, cannot wait to be able to use it!

A bigger sandbox for your web apps

Last (but not least), I would like to be able to build any type of app on the web. Why is it not possible now?

First, there is no way to save data on the disk. Yes, IndexedDb is a thing, but it is not access to a disk in a POSIX way. I would love to be able to compile SQLite to webassembly and make it run for my app. I would like to have the same freedom to same bytes with random access on a disk so I can build my own file format for an audio editing app. This is a nice step in the right direction.

Same with network access. Imagine I would like to build a email PWA. Why is it not possible? Because you cannot have IMAP (or POP) in your browser, because you cannot access TCP sockets.

Perhaps when WASI becomes standard and available on all platform we will start to be there?

Discuss this post on Mastodon

Integrate Popper.js in React

Mon, 25 Feb 2019 16:00:00 GMT

Edit: You might want to use Floating UI now, the modern successor to PopperJS (by the same team)

Until recently I used the library react-popper to add poppers (i.e. floating elements, anchored to a target) in my pages using Popper.js.

Hooks makes it easy to do it yourself directly. With this article you should be able to take a scaffold of a basic usePopper hook and modify it for your specific needs. We follow an approach inspired by react-popper.

We have a menu component that we want to display next to a target. Because we can, we introduce an arrow as well. Assuming that we have the components already built, we need to:

initialise Popper.js with references
retrieve the changed style that it computes

So this is what how our API will look like as well

const PopperComponent = () => {
  const [targetNode, setTargetNode] = useState(null);
  const [menuNode, setMenuNode] = useState(null);
  const [arrowNode, setArrowNode] = useState(null);

  const { styles, placement, arrowStyles } = usePopper({
    referrenceNode: targetNode,
    popperNode: menuNode,
    arrowNode,
  });

  return (
  <>
    <Target ref={setTargetNode}>
    <Portal>
      <Popper ref={setMenuNode} style={styles} data-placement={placement}>
        <Menu />
        <Arrow ref={setArrowNode} style={arrowStyles} />
      </Popper>
    </Portal>
  </>
  );

Note that we use useState and not useRef to get to the reference of the DOM node, why?. With useRef we would not refresh our popper on the change of node (which would be an issue). Here we actually use a simple version of this example from the React FAQ, where the ref function is just a setState.

Note that I like to use react-portal to create a Portal element – it makes sure whatever is in the popper is not influenced by the styling from parent elements. But this is not strickly necessary.

So what does usePopper look like? If we go with the most simple configuration we have the following hook.

const usePopper ({
  referrenceNode,
  popperNode,
  arrowNode,
  placement,
}) => {
  const [popperStyles, updatePopperState] = usePopperState(placement);
  const popperInstance = useRef();

  // manage the popper instance lifecycle
  useEffect(
    () => {
      // We refresh the popper instance on every config change
      if (popperInstance.current) {
        popperInstance.current.destroy();
        popperInstance.current = null;
      }

      if (!referrenceNode || !popperNode) return;

      popperInstance.current = new PopperJS(
        referrenceNode,
        popperNode,
        {
          placement,
          modifiers: {
            arrow: {
              enabled: !!arrowNode,
              element: arrowNode,
            },
            applyStyle: {
              // we manage to apply the styles ourselves
              enabled: false
            },
            updateStateModifier: {
              enabled: true,
              order: 900,
              fn: updatePopperState,
            },
          },
      });
      popperInstance.current.enableEventListeners();

      return () => {
        popperInstance.current.destroy();
        popperInstance.current = null;
      };
    },
    [ arrowNode, referrenceNode, popperNode, placement ]
  );

  useEffect(() => {
    if (popperInstance.current) {
      popperInstance.current.scheduleUpdate();
    }
  });

  return popperStyles;
};

What do we do? We have a popper instance that generates a style configuration on each refresh. This style configuration is part of the state. On every change of the styles a render will be triggered.

With useEffect we refresh the configuration of the popper. This means that poppers will always take into account the latest configuration (or latest targets if they change).

Finally we make sure the popper position is always scheduled when the component is re rendered.

What does usePopperState do? It is a simple mapper between what popper.js returns and what we want to export as the usePopper API.

const usePopperState = placement => {
  const [currentStyles, setStyles] = useDiffedState({
    position: 'absolute',
    top: 0,
    left: 0,
    opacity: 0,
    pointerEvents: 'none',
  });
  const [currentArrowStyles, setArrowStyles] = useDiffedState({});
  const [currentOutOfBoundaries, setOutOfBoundaries] = useState(false);
  const [currentPlacement, setPlacement] = useState(placement);

  const updatePopperState = updatedData => {
    const {
      styles,
      arrowStyles,
      hide,
      placement: updatedPlacement,
    } = updatedData;

    setStyles(styles);
    setArrowStyles(arrowStyles);
    setPlacement(updatedPlacement);
    setOutOfBoundaries(hide);
    return updatedData;
  };

  const popperStyles = {
    styles: currentStyles,
    placement: currentPlacement,
    outOfBoundaries: currentOutOfBoundaries,
    arrowStyles: currentArrowStyles,
  };

  return [popperStyles, updatePopperState];
};

You could modify it to allow for a more detailed management of the default values for both the default style of the popper or the arrow.

useDiffedState is a helper hook that allows us to refresh our state only when necessary (it might be premature optimisation, but hey it was fun). This exposes the API from useState, but refreshes objects only if their value is different.

import { useState } from 'react';
import isEqual from 'lodash/isEqual';
import isFunction from 'lodash/isFunction';

const useDiffedState = initVal => {
  const [storedValue, setStoredValue] = useState(initVal);

  const setValue = value => {
    const valueToStore = isFunction(value) ? value(storedValue) : value;
    setStoredValue(prevState => {
      if (isEqual(prevState, valueToStore)) {
        return prevState;
      }
      return valueToStore;
    });
  };
  return [storedValue, setValue];
};

This is just a start, because Popper.js allows you to configure a lot what you might want to do. For instance, you might want to configure if the position is fixed, or work with modifiers.

You can find a more complete example published here.

Discuss it on Mastodon

Edit March 22, 2019: Put the DOM node as state instead of ref, as it can change. Thanks to this comment

Groups of people on the fediverse

Mon, 28 Jan 2019 15:00:00 GMT

Edit: While the code is still on GitHub, Federa is not up anymore. You can play with Guppe that has the same philosophy.

People around me use Facebook groups a lot. They get lot of value out of them. These groups are used for vague communities organisation. You want to share information about flats to rent in your city? There is a group for that. Try to give out furnitures? Same, a group for that. Exchange tips on how to repair your car? You know where I am going.

Mailing lists used to fill that need. Why not anymore? It is more difficult to join one, mailing lists tend to have crummy interfaces. An email you receive feels more personal (even when it is not). Generally there is less a sense of community in a mailing list than on Facebook.

What about forums? The old phpBB. They also tend to be replaced by Facebook groups. Convenience won here mostly. How many people know how to run and update a server to run a Discourse or a phpBB? How many want to pay for it?

And in both case, the discovery factor is quite important. It is easy to find out about a group a friend shares to (it appears in your timeline) – how would you discover a mailing list a friend is part of? No serendipity in finding a forum either, you need to search for it.

The fediverse offers a new possibility to create a tool that is as good as Facebook groups – Mastodon is a social inbox with a familiar interface. We just need to have a concept of group.

Isn’t there one with (hash)tags? Kind of. But tags are completely informal, they do not appear in your timeline / inbox and, are not federated (as far as I know).

What about instances as communities? I feel ambivalent about the local feed. In a way it is a great tool to discover new people on my instance. But on the other hand it forces me to be careful about what I share. I want to avoid polluting the feed with things that are not relevant to the community of my instance. Should I create a new identity for each topic I might be interested in?

So I went and created something new – I called it Federa groups. For now it is fairly simple. You log in with your Mastodon identity. Then create a group, let’s call it starwars for the sake of the example. You (or anyone) just needs to follow this new group within Mastodon then at @starwars@group.federa.site. If you mention the group in a toot it will be boosted to all the people following this group.

Federa groups is a very simple service for now. There is UX as well as security work to be done for sure. And I can think of many additional feature to add (private groups, search,…). But first I want to see if the idea has legs. Contact me if you have any feedback on these groups! Tell me why I should keep investing some time in it! Or even better, help me build it!

Discuss this on Mastodon

Carrots

Small web apps are perfect for (tabletop gaming) tools

The current landscape of 2D CAD libraries

#Solvespace and offsets

#Clipper and polygons

#Cavalier contours and a CAD data structure

#Flatten, maker.js and Bézier curves

#Additional considerations

#What did I choose for replicad?

#TL;DR: my list of features

Bling My Thing - decorate your 3D models

Make custom storage solutions with deckinabox

#Models for folding paper or cardstock

#Models for 3D printing

#CodeCAD is great

Stack homemade cardboard boxes

3D printed parts for a baby gym arch

How I create papercraft statues (using my Silhouette Cameo)

#First step: the 3D model

#Finding a low poly statue

#Lowering the resolution of a high poly statue

#Scanning a real world object

#Buiding the model yourself from scratch

#Second Step: Making it flat

#Third Step: cutting

#Fourth Step: folding and pasting