---
title: "Sliced file size by format: one plate, 29 files"
description: "The same plate sliced into 29 files: 4.3 MB as an Anycubic file, 145 MB as .cbddlp. What each container weighs and how much grey it keeps."
url: "https://encrust.app/blog/sliced-file-size-by-format/"
lang: "en"
updated: "2026-11-17"
---

[ Resin printing, file formats and how a slicer works](https://encrust.app/blog/)

File formats

# One plate, 29 files: what each container weighs and keeps

[By Vladimir Varvorkin](https://encrust.app/about/) Updated November 17, 2026 8 min read

The same 30 mm cube, sliced once, is 4.3 MB as an Anycubic .pwmx and 145 MB as a .cbddlp, because .cbddlp writes each layer eight times to carry grey. The files differ at the edge pixels, not in the bulk of the light. Measured with Encrust on one 1440 x 2560 px panel; nothing was printed.

## On this page

1. [The measurements](https://encrust.app/blog/sliced-file-size-by-format/#the-measurements)
2. [Why a .cbddlp is so heavy](https://encrust.app/blog/sliced-file-size-by-format/#why-a-cbddlp-is-so-heavy)
3. [What each container keeps of the grey](https://encrust.app/blog/sliced-file-size-by-format/#what-each-container-keeps-of-the-grey)
4. [Does the container change the print?](https://encrust.app/blog/sliced-file-size-by-format/#does-the-container-change-the-print)
5. [Repeat it](https://encrust.app/blog/sliced-file-size-by-format/#repeat-it)

A `.cbddlp` of one 30 mm cube is 145 MB. The same layers as an Anycubic `.pwmx` are 4.3 MB, as a `.goo` 5.5 MB, as a `.sl1` 20 MB. Nothing about the model changed between them. The container did.

Here is the part that surprised us. The `.svgx`, the one container in the set that stores polygons instead of pixels, came out at 21.7 MB: five times the Anycubic file, for a part that is a single outline per layer. We expected the vector file to be the small one. We did not isolate why it isn’t; the command-line reference says only that the `.svgx` costs “by the panel rather than by the model”.

Note

One plate, one cube, one panel, one machine’s output. The cube has vertical walls, so every layer is the same mask and the totals scale with the layer count. A model with overhangs, hollows or supports gives other byte counts. None of these files was printed.

## The measurements

Measured on 2026-10-10.

The plate is one 10 mm cube from Encrust’s own test fixtures, scaled by 3 (30 mm) and turned 30 degrees about Z so its edges cross the pixel grid at an angle. It was sliced at 0.05 mm, which is 600 layers, for the Anycubic Photon profile’s panel: 1440 x 2560 px over 68.04 x 120.96 mm. Every container got the same panel and the same resin file, so the only variable is the extension. All sizes are bytes of the file as `encrust slice` wrote it, from a release build on a Linux sandbox; no timing was taken. Two runs of the `.goo` differed in two bytes of the header and not in size.

“Greys on layer 300” is the number of distinct pixel values in that layer’s mask after `encrust info --layer 300 --png` read the file back. “Lit pixels” is the count of non-zero pixels in the same mask. The first row is the reference: nothing is lost there.

| Container                                          | Bytes       | Against .goo | Greys on layer 300 | Lit pixels, layer 300 |
| -------------------------------------------------- | ----------- | ------------ | ------------------ | --------------------- |
| .goo                                               | 5,526,513   | 1.00         | 248                | 404,525               |
| .ctb v4                                            | 4,820,447   | 0.87         | 126                | 404,525               |
| .ctb v5                                            | 4,820,511   | 0.87         | 126                | 404,525               |
| .cbddlp                                            | 145,340,772 | 26.3         | 9                  | 404,044               |
| .photon                                            | 145,340,772 | 26.3         | 9                  | 404,044               |
| Anycubic, revision 1 (.pw0, .pwx)                  | 4,271,856   | 0.77         | 16                 | 404,276               |
| Anycubic, revision 516 (.pwmx and eight more)      | 4,272,120   | 0.77         | 16                 | 404,276               |
| Anycubic, revision 517 (.pwmb, .pm5 and five more) | 4,272,344   | 0.77         | 16                 | 404,276               |
| .sl1                                               | 20,401,713  | 3.69         | 248                | 404,525               |
| .sl1s                                              | 20,401,715  | 3.69         | not read           | not read              |
| .zip                                               | 20,533,355  | 3.72         | 248                | 404,525               |
| .cws                                               | 20,468,246  | 3.70         | 248                | 404,525               |
| .cxdlp v3                                          | 13,573,205  | 2.46         | 248                | 404,525               |
| .cxdlp v4 (CL-60)                                  | 4,794,592   | 0.87         | 126                | 404,525               |
| .svgx                                              | 21,686,981  | 3.92         | 2                  | 403,124               |

The Anycubic rows group 17 files. Layer 300 was read back from one file per revision (`.pw0`, `.pwmx`, `.pwmb`); the other extensions of a revision have the same size, within the few bytes that differ between revisions, and were not read back. “Greys” counts 0 as one value, so 248 means 247 shades plus black. `.goo` shows 248 of the 256 possible values on this layer: the edge of one outline does not use them all.

Against the Anycubic size, the `.cbddlp` is 34 times larger, the `.svgx` 5 times and the `.cxdlp` v3 2.8 times its own v4.

## Why a .cbddlp is so heavy

A `.cbddlp` stores one bit per pixel, so a layer is written eight times over, once per grey threshold, and the printer adds the passes back up. [The format note](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/formats/chitu.md) puts a floor under that: runs are at most 125 pixels, one byte each, “whether they are lit or not”.

That floor is computable. This panel has 3,686,400 pixels, which is at least 29,492 bytes a pass. Times 8 passes and 600 layers:

```
ceil(3,686,400 / 125) * 8 * 600 = 29,492 * 4,800 = 141,561,600 bytes
```

The file is 145,340,772 bytes. The floor alone is 97% of the file, so the size is close to a function of the panel, not the cube: a 4098 x 2560 px panel cannot go below 671 kB a layer, as the same note states.

The other containers do not pay by the pixel. A `.goo` and an Anycubic file store runs, so the dark panel around the cube is cheap: in the Anycubic file a run of up to 4095 pixels is two bytes. The three PNG containers (`.sl1`, `.zip`, `.cws`) hold one compressed greyscale image per layer, about 34 kB each here (20.4 MB over 600 layers).

## What each container keeps of the grey

A mask holds a value from 0 to 255 per pixel, and an edge pixel is partly covered, so it is partly lit. [The rasterisation note](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/design/rasterisation.md#the-grey-the-panel-will-actually-hold) says why that matters: “Below roughly half the range a pixel stops curing rather than curing less.” What a container does with the grey is therefore a statement about the edge.

Layer 300 of this plate has 2,801 edge pixels strictly between black and white. What survived, read back from each file:

| Container                                | Grey it carries      | Result on layer 300                                                    |
| ---------------------------------------- | -------------------- | ---------------------------------------------------------------------- |
| .goo, .sl1, .sl1s, .zip, .cws, .cxdlp v3 | all eight bits       | the mask as drawn: 2,801 edge pixels                                   |
| .ctb v4 and v5, .cxdlp v4 (CL-60)        | seven bits           | 126 values; the mask is halved on the way in                           |
| Anycubic, every revision                 | four bits, one pass  | 16 values, 17 apart; 249 pixels under 16 fell to black                 |
| .cbddlp, .photon                         | eight one-bit passes | 9 values (0, 31, 63, … 255); 481 pixels under 31 fell to black         |
| .svgx                                    | none                 | 2 values; 1,401 pixels under 128 fell to black, the rest went to white |

The counts of pixels that fell to black are exact: they are the number of pixels in the `.goo` mask below 16, below 31 and below 128, and each matches the drop in lit pixels in the table above (404,525 less 249, 481 and 1,401). The thresholds come from the format notes: an Anycubic value [loses its low nibble](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/formats/anycubic.md), and “Anything under 16 falls to nibble zero and lights nothing”; the `.cbddlp` ladder starts at 31; and [the .svgx mask is cut at 128](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/formats/svgx.md).

The seven-bit `.ctb` is the quiet one. It halves a value and doubles it back with the lowest bit set, so two neighbours collapse into one: 126 values, no pixel goes dark, and 255 stays 255\. The `.cxdlp` takes the same two paths by version: version 3 stores lines with all eight bits, version 4 picks its codec by the model code in the header: three bits (paired rows) for `R009`, `R026` and `R027`, six bits for `R012`, seven bits for `R013`, `R018` and any other code, the `.ctb` family’s seven-bit runs ( [the Creality note](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/formats/creality.md#a-version-4-layer)). Encrust writes the codec the code calls for. The size follows: 13.6 MB at version 3, and 4.8 MB at version 4 with the `CL-60` code used here. That the line list is the reason for the size is our reading of the note, which says version 3 “holds a layer as a list of vertical lines” of six bytes; we did not isolate it.

## Does the container change the print?

On this plate the light barely moves. Summing every pixel value of layer 300 gives a number that stands for the light that layer delivers, if a pixel’s grey were its dose, which is an assumption and not a measurement of any resin:

| Container | Sum of pixel values, layer 300 | Against .goo |
| --------- | ------------------------------ | ------------ |
| .goo      | 102,796,643                    | reference    |
| Anycubic  | 102,796,484                    | \-0.0002%    |
| .svgx     | 102,796,620                    | \-0.00002%   |
| .ctb      | 102,797,997                    | +0.001%      |
| .cbddlp   | 102,753,332                    | \-0.04%      |

Everything within 0.04% says the edge pixels, a few thousand of 400,000 lit ones, are where the files differ and that no container shifts the bulk. It does not say a print is the same. Whether a dim edge pixel cures at all is a property of your panel and your resin, and we have measured neither here. The rasterisation note’s own warning is that a pixel below about half the range may be left liquid, and a printer profile’s `grey_floor` sets the dimmest grey Encrust writes: it is 0 by default, which keeps the whole ramp down to 1, and a panel that leaves a dim pixel uncured asks for a floor of its own. Where the container cuts at 128 by itself (the `.svgx`) or keeps only nine values (the `.cbddlp`), the container has already made that choice for the panel.

If a printer accepts two containers, its firmware and its maker’s documentation decide. This post describes what the files carry; it does not rank them.

## Repeat it

Build the command line from the Encrust source (`cargo build --release -p encrust-cli`), then run the lines below. The resin file in them exists to make files of the right size and nothing else: its exposure, lift and retract values are not settings for a print. For a print, take your resin maker’s figures at your layer height and your printer maker’s motion settings, and calibrate.

```
# the panel: the Photon profile, kept as a file so the Creality copies match it
# the .cxdlp writer only needs a model code (CL-60) in the machine name
encrust profiles show anycubic-photon -o photon.toml
sed 's/^name = .*/name = "study CL-60"/; s/^output = .*/output = "cxdlp3"/' photon.toml > cx3.toml
sed 's/^name = .*/name = "study CL-60"/; s/^output = .*/output = "cxdlp4"/' photon.toml > cx4.toml

# the resin: a file of your own; the catalogue ships none
cat > grey.toml <<'EOF'
name = "study-grey"
layer_height_mm = 0.05
exposure_s = 2.5
bottom_exposure_s = 30.0
bottom_layers = 5
light_off_delay_s = 1.0
lift_distance_mm = 6.0
lift_speed_mm_min = 60.0
retract_speed_mm_min = 120.0
EOF
# These values only make files of the right size; they are not exposure advice.
# For a real print, use your resin maker's and your printer maker's settings.

# the plate: the repository's 10 mm test cube, scaled by 3 and turned 30 degrees
CUBE=crates/encrust-app/tests/fixtures/cube.stl
for ext in goo ctb cbddlp photon sl1 sl1s zip svgx cws pwmx pwmb pw0; do
  encrust slice $CUBE --profile photon.toml --material grey.toml \
    --scale 3 --rotate 0,0,30 --center -l 0.05 --no-progress -q -o plate.$ext
done
encrust slice $CUBE --profile photon.toml --material grey.toml --scale 3 --rotate 0,0,30 --center -l 0.05 --ctb-version 5 -o plate-v5.ctb
# .ctb v4 is the default for .ctb; .cxdlp takes its version from the profile
encrust slice $CUBE --profile cx3.toml --material grey.toml --scale 3 --rotate 0,0,30 --center -l 0.05 -o plate-v3.cxdlp
encrust slice $CUBE --profile cx4.toml --material grey.toml --scale 3 --rotate 0,0,30 --center -l 0.05 -o plate-v4.cxdlp

# one layer back out of any file, then count its pixel values
encrust info plate.pwmx --layer 300 --png layer.png
python3 -c "from PIL import Image; from collections import Counter; c=Counter(Image.open('layer.png').tobytes()); print(len(c), sum(v for k,v in c.items() if k), sum(k*v for k,v in c.items()))"
```

The three numbers it prints are the greys, the lit pixels and the sum of values from the tables. Left without `-q`, a run warns that the Photon profile reads `.photon`, not the extension you asked for; that is the point of writing every container from one panel. A `.cxdlp` is refused unless the machine’s name carries a model code such as `CL-60`, which is why the Creality copies are renamed ( [the Creality note](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/formats/creality.md) says the firmware matches it).

Sizes are from `ls -l` on those files.

One limit on the study. The Photon’s 1440 x 2560 px panel is the largest that [the command-line reference](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/cli.md#output-exit-codes-and-ctrl-c) counts as a `.cbddlp` machine’s own, and a bigger panel makes it warn before it writes a layer. Both `.cbddlp` and `.svgx` “cost by the panel rather than by the model”, in that document’s words, so on a larger panel their rows grow.

## Sources

- [Encrust: the command line, "Output, exit codes and Ctrl-C"](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/cli.md#output-exit-codes-and-ctrl-c)  · The extension picks the container, and the paragraph on what each one pays for grey
- [Encrust: rasterisation, "The grey the panel will actually hold"](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/design/rasterisation.md#the-grey-the-panel-will-actually-hold)  · The 255 greys a mask can ask for, the ladder and the floor
- [Encrust: the Chitu family (.ctb, .cbddlp, .photon)](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/formats/chitu.md)  · Seven bits of grey in a .ctb, eight one-bit passes in a .cbddlp, and the run-length floor
- [Encrust: the Anycubic Photon Workshop containers](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/formats/anycubic.md)  · Four bits of grey, the revisions, and the run-length chunks
- [Encrust: the .svgx](https://github.com/vvvlladimir/Encrust/blob/v0.9.0/docs/formats/svgx.md)  · Layers as polygons, and the grey of 128 a mask is cut at

## More in File formats

- [What your printer ignores in the file you sliced ](https://encrust.app/blog/what-resin-printer-firmware-ignores/)
- [Which file does your resin printer read? ](https://encrust.app/blog/which-file-format-resin-printer/)
- [Halve the layer height and the exposure does not halve ](https://encrust.app/blog/resin-exposure-when-layer-height-changes/)
- [All posts ](https://encrust.app/blog/)

---

[ Encrust](https://encrust.app/)

Free and open source under AGPL-3.0, written in Rust. Your files stay on your computer.

## Product

[Download](https://encrust.app/download/) [Printers](https://encrust.app/printers/) [Web app](https://encrust.app/app/)

## Learn

[Guides](https://encrust.app/guides/) [Blog](https://encrust.app/blog/) [FAQ](https://encrust.app/faq/) [Changelog](https://github.com/vvvlladimir/Encrust/blob/main/CHANGELOG.md)

## Project

[About](https://encrust.app/about/) [Source code](https://github.com/vvvlladimir/Encrust) [Discussions](https://github.com/vvvlladimir/Encrust/discussions) [Report a bug](https://github.com/vvvlladimir/Encrust/issues)

Encrust prepares files for machines that cure resin with UV light. It can’t know whether your settings suit your resin, printer or model, so check its output before a long print. Provided without warranty, as the licence says.

[Privacy](https://encrust.app/privacy/) [Impressum](https://encrust.app/impressum/) [Datenschutzerklärung](https://encrust.app/datenschutz/)
