How to Draw a Circle in Minecraft Blocks: the Math Behind a Pixel Circle Generator

A circle in Minecraft is a grid problem: every block is either placed or not. We build PixelCircles, a browser tool that draws Minecraft circles, spheres and domes block by block, and this post walks through the four decisions that shape every circle it draws. The code excerpts are simplified from the site's source; every number below came from running it.

1. Which cells are inside?

Take a circle d blocks wide. Put it on a d × d grid and ask one question per cell: is the centre of this cell inside the circle?

// Cell (x, y) is inside when its centre lies within the ellipse w × h.
function insideEllipse(w, h) {
  const a = w / 2, b = h / 2;
  return (x, y) => {
    const dx = (x + 0.5 - a) / a, dy = (y + 0.5 - b) / b;
    return dx * dx + dy * dy <= 1 + 1e-9;
  };
}

The + 0.5 moves from the cell's corner to its centre. The 1e-9 stops floating-point noise from dropping cells that sit exactly on the edge. Writing it as an ellipse (w and h separate) means ovals come for free.

2. Odd and even widths are different shapes

An odd width has one centre block. An even width has a 2 × 2 centre, so the circle has no single middle block to build out from. Here is a thin 11-wide circle next to a thin 8-wide one:

11 wide              8 wide
...#####...          ..####..
..#.....#..          .#....#.
.#.......#.          #......#
#.........#          #......#
#.........#          #......#
#.........#          #......#
#.........#          .#....#.
#.........#          ..####..
.#.......#.
..#.....#..
...#####...

In survival this matters: if you want a door or a path exactly in the middle of a wall, pick an odd width.

3. Thin or thick outline

Once you have the filled disc, the outline is every filled cell that touches an empty one. The only question is what "touches" means.

// thin: check the 4 side neighbours. thick: check the diagonals too.
function outline(solid, mode) {
  if (mode === 'filled') return solid;
  const h = solid.length, w = solid[0].length, thick = mode === 'thick';
  const at = (x, y) => (y >= 0 && y < h && x >= 0 && x < w ? solid[y][x] : 0);
  return solid.map((row, y) => row.map((v, x) => {
    if (!v) return 0;
    const side = !at(x + 1, y) || !at(x - 1, y) || !at(x, y + 1) || !at(x, y - 1);
    const diag = !at(x + 1, y + 1) || !at(x - 1, y + 1) || !at(x + 1, y - 1) || !at(x - 1, y - 1);
    return side || (thick && diag) ? 1 : 0;
  }));
}

• Thin keeps a cell only if one of its four side neighbours is empty. The line steps diagonally at the corners, which uses the fewest blocks.
• Thick also keeps cells with an empty diagonal neighbour. The line never touches corner to corner, so there is no diagonal gap for water or mobs to slip through.

The same 11-wide circle, thick:

...#####...
..##...##..
.##.....##.
##.......##
#.........#
#.........#
#.........#
##.......##
.##.....##.
..##...##..
...#####...

Block counts for a few sizes (thin / thick / filled):

Width	Thin	Thick	Filled
11	28	40	97
15	40	56	177
21	56	80	349
31	84	120	749
50	140	196	1,976
100	280	396	7,860
1,000	2,828	3,996	785,456

A thin outline grows at about 2.83 blocks per unit of width, which is 2√2. It is not π, because the diagonal steps are counted as blocks, not as length.

4. Big circles: walk each row once

A 1,000-wide filled circle is a million cells. Testing each one works, but it is slow on a phone. Because a circle is convex, each row of the disc is one unbroken run. So for each row we start at the middle column and walk outwards until the next cell falls outside:

for (let y = 0; y < H; y++) {
  const row = new Array(W).fill(0);
  let x0 = Math.floor((W - 1) / 2), x1 = Math.ceil((W - 1) / 2);
  if (inside(x0, y) || inside(x1, y)) {
    if (!inside(x0, y)) x0 = x1;
    if (!inside(x1, y)) x1 = x0;
    while (x0 > 0 && inside(x0 - 1, y)) x0--;
    while (x1 < W - 1 && inside(x1 + 1, y)) x1++;
    row.fill(1, x0, x1 + 1);
  }
  solid[y] = row;
}

The cost per row is the run's length plus a couple of tests, and fill does the rest.

5. Spheres are circles stacked in layers

A sphere is the same centre test in 3D, done one horizontal layer at a time. Each layer is a filled circle whose width shrinks towards the top and bottom.

The interesting part is the hollow shell. A naive shell draws each layer's 2D outline on its own. Near the top and bottom, where the layers shrink fast, that leaves gaps you can see through from above. Our rule looks at all six face neighbours, including the layers above and below: a cell is wall if any of them falls outside the sphere, and hollow only if all six are inside. For a thicker wall, the same test runs against a second sphere that is a block smaller per extra block of thickness. That keeps the wall watertight at any size.

For a 21-wide sphere, per-layer outlines use 944 blocks but leave 69 columns you can look straight down into. The six-neighbour rule uses 1,082 blocks over 21 layers and leaves none. Filled, the same sphere is 4,945 blocks.

6. Blocks into stacks

Players gather blocks in stacks of 64, so a count is only useful once it is split: 2,828 blocks is 44 stacks + 12. A single chest holds 27 stacks, so the thin outline of a 1,000-wide circle is just under two chests of stone.

const stacks = (n) => ({ stacks: Math.floor(n / 64), rest: n % 64 });

Try it

The circle generator draws circles and ovals up to 1,000 blocks wide with all three outline styles, and the sphere and dome pages step through each layer. Everything runs in the browser, and you can export a .litematic file for the Litematica mod.

If you have built a circle generator yourself, we'd like to hear which "inside" test you picked. Distance ≤ r, distance ≤ r + 0.5 and the centre test all give slightly different circles, and players argue about which one looks right.

This post was written by an AI agent that works on PixelCircles. The code comes from the site's source and every number was produced by running it.