OpenComputers · Setup guide · Intermediate

OpenComputers 3D Printer and Hologram Projector Setup Guide

Transform your OpenComputers network from a simple text terminal into an interactive architectural and visual suite. In this guide, you will learn how to configure a 3D Printer to fabricate custom multi-state decorative blocks, and set up a Hologram Projector to render real-time 3D voxel displays. Mastering these peripherals allows you to create custom doors, buttons, and dynamic base status displays that standard blocks cannot achieve.

What you need

  • A working OpenComputers Computer running OpenOS (with Screen, Keyboard, and Hard Disk Drive)
  • 3D Printer
  • Hologram Projector (Tier 1 or Tier 2)
  • Chamelium (check JEI for crafting, typically requires Gravel, Redstone, Coal, and Water)
  • Ink Cartridge (filled using cyan, magenta, yellow, and black dyes)
  • OpenComputers Cables
  • Power Converter and an external mod power source (if energy is enabled in your configuration)
  • OpenPrograms Floppy Disk (looted or crafted, optional for built-in example scripts)

Step by step

  1. 1Connect the Peripherals to Your Network

    Place your 3D Printer and Hologram Projector near your main Computer Case. Connect both blocks to the computer using OpenComputers Cables, or place them directly adjacent to the case so they share a physical face. Ensure your network has a Power Converter attached to an external energy source, as both printing and projecting consume continuous power during operation.

    Tip: Keep at least three blocks of empty air directly above the Hologram Projector so the voxel projection is not obstructed by ceiling blocks.

  2. 2Prepare and Load the 3D Printer

    Craft several pieces of Chamelium, which serves as the base physical matter for all printed shapes, alongside an Ink Cartridge filled with dyes. Right-click the 3D Printer to open its internal inventory. Place the Chamelium into the top-left material slot and the filled Ink Cartridge into the bottom-left ink slot. You will see the internal progress bars fill up as the printer consumes the items to fill its internal buffers.

    Tip: You can refill an Empty Ink Cartridge in a crafting grid by surrounding it with the four primary printing dyes (Cyan, Magenta, Yellow, and Black)—check JEI for the exact arrangement.

  3. 3Understand 3D Model Structure

    Before printing, you must define a model using a table structure or a configuration file. A 3D print occupies a 16x16x16 coordinate grid (from 0 to 16 on X, Y, and Z axes) and consists of multiple bounding boxes called shapes. Each shape is defined by its minimum and maximum coordinates, a texture string (stolen from existing vanilla or mod blocks, like 'minecraft:iron_block'), and an optional tint color.

    Tip: Models can have two distinct states: an inactive 'off' state and an active 'on' state, allowing your single printed block to act as a working door, lever, or trapdoor.

  4. 4Send a Print Job via Lua

    Boot up your computer and open the interactive Lua prompt by typing 'lua' and pressing Enter. First, access the printer component by typing `p = component.printer3d` and clear any old data with `p.reset()`. Add a simple base box by running `p.addShape(0, 0, 0, 16, 8, 16, "minecraft:stone")` and label it with `p.setLabel("Custom Slab")`. Finally, execute `p.commit(1)` to start printing one copy of your block.

    Tip: If you have the OpenPrograms floppy disk, you can install the 'print3d' utility onto your hard drive to print complex `.3dm` model files directly from the command line without typing manual Lua commands.

  5. 5Define Interactive States on Printed Blocks

    To make a block change shape when right-clicked, you must assign shapes to different states before calling commit. When using `p.addShape(minX, minY, minZ, maxX, maxY, maxZ, texture, state, tint)`, the eighth argument ('state') is a boolean. Pass `false` for shapes that appear by default, and `true` for shapes that appear when the player interacts with the block. You can also call `p.setRedstoneEmitter(true)` to make the block output a redstone signal when toggled into its active state.

    Tip: A single 3D print has a strict limit on the total number of shapes it can hold across both states; check the printer status or in-game manual if your commit command fails due to complexity.

  6. 6Initialize the Hologram Projector

    Exit or stay in the Lua prompt to interact with your Hologram Projector. Assign the component to a variable by typing `h = component.hologram` and wipe the display clean using `h.clear()`. The projector controls a 3D grid of voxels above it, spanning 48 blocks wide, 32 blocks tall, and 48 blocks deep. You can adjust the overall physical size of the projection in the world by running `h.setScale(1.0)`, where the number ranges from 0.33 to 3.0.

    Tip: If your projection looks too high or low, use `h.setTranslation(x, y, z)` to shift the hologram's render offset without breaking and moving the projector block.

  7. 7Render Voxels and Adjust Colors

    To turn on individual voxels in the display, use the `h.set(x, y, z, value)` function. For example, typing `h.set(24, 16, 24, 1)` will light up a single voxel right in the center of the projection using color index 1. For faster rendering, use `h.fill(x, z, minY, maxY, value)` to draw an entire vertical column at once. If you are using a Tier 2 Hologram Projector, you can change the hex colors of the palette using `h.setPaletteColor(index, hexColor)`.

    Tip: Pass a value of 0 or `false` into the `h.set()` function to turn a specific voxel off.

How it works

Both the 3D Printer and the Hologram Projector act as external network components that expose their specific hardware methods to the computer's Component API. Because OpenComputers runs inside a persistent Lua sandbox, the computer does not actually render graphics itself; instead, your Lua scripts make API calls over the cable network, instructing the peripheral blocks to update their internal NBT data or rendering buffers.

For the 3D Printer, each `addShape` call appends an Axis-Aligned Bounding Box (AABB) to the printer's internal memory buffer. When you execute `commit()`, the printer calculates the total volume of all boxes to determine the Chamelium cost, and calculates the surface area to determine the Ink cost. Once printed, the resulting item holds all those coordinates and texture reference strings inside its item NBT data, telling the Minecraft client how to render the custom block geometry.

The Hologram Projector operates as a volumetric bitmap display. Rather than storing individual shapes, it maintains a compressed bit-array in memory representing the 48x32x48 grid. Tier 1 projectors use 1 bit per voxel ( simply on or off in a single monochrome color), while Tier 2 projectors allocate 2 bits per voxel, allowing for three distinct selectable colors plus an 'off' state (0). Sending updates via `h.set()` or `h.fill()` modifies this array and syncs the changed voxel chunks to nearby players.

Common mistakes

  • Forgetting to call `p.reset()` before starting a new 3D print script; the printer retains the shapes from the previous job in its buffer, which will merge your old model with your new one.
  • Using invalid texture names in `addShape()`; if the texture string does not match an actual block resource location loaded in your modpack, the printed block will render with the purple-and-black missing texture checkerboard.
  • Exceeding the maximum shape limit on the 3D Printer; trying to replicate curves using dozens of tiny 1x1x1 voxel cubes will quickly hit the complexity cap—combine adjacent cubes into single larger rectangular boxes instead.
  • Attempting to use color indices 2 or 3 on a Tier 1 Hologram Projector; Tier 1 hardware only supports index 1 (on) and 0 (off), and passing higher numbers will result in a Lua error.

FAQ

Why is my 3D Printer pausing or refusing to start the print job?

Check three things: ensure the internal Chamelium bar and Ink bar have enough material for the complexity of your model, verify that the output slot isn't already full, and check that your computer network has sufficient energy.

Can I recycle 3D printed blocks if I make a mistake in the model?

Yes, you can smelt unwanted 3D printed blocks in a standard Furnace to recover some of the Chamelium base material, though the ink used is permanently lost.

Why can't I see the hologram even though the script ran without errors?

Make sure your Minecraft client graphical settings or the OpenComputers configuration file does not have hologram rendering distance set too low, and verify that solid blocks are not completely covering the top face of the projector.

How do I find valid texture strings for my 3D prints?

You can craft the Texture Picker tool from OpenComputers; right-clicking any standard block in the world with it will display the exact texture string you need to type into your Lua script.

By combining the component API with Chamelium-fed 3D Printers and Hologram Projectors, you can program custom interactive architecture and volumetric 3D displays directly from your OpenComputers terminal.

More OpenComputers guides

OpenComputers · Getting startedHow to Build Your First Computer and Install OpenOSIn this guide, you will learn how to assemble your very first modular Tier 1 computer in OpenComputers and install the standard OpenOS operating system onto its hard drive. Mastering this initial setup is essential because it provides the foundational terminal required to write Lua scripts, control redstone, and automate complex factory systems.Beginner8 steps
OpenComputers · ProgressionOpenComputers Hardware Tiers and Progression GuideOpenComputers relies on a strict modular tier system where every component, from memory sticks to graphics cards, must be carefully matched to your computer case. This guide will walk you through the progression from a basic Tier 1 machine up to a fully loaded Tier 3 Server Rack. Mastering these hardware limits ensures you never waste valuable resources on incompatible parts or crash your scripts due to insufficient memory.Beginner7 steps
OpenComputers · PowerOpenComputers Power Converter and Networking ExplainedIn OpenComputers, a single Cable carries power, component connections, and network messages all at the same time. While convenient, this all-in-one behavior causes massive chaos when you try to power two computers from the same energy source, as they will accidentally hijack each other's screens and keyboards. This guide explains how to convert modded energy using the Power Converter and how to isolate your systems using Power Distributors and Relays.Beginner7 steps
OpenComputers · ExplainedOpenComputers Component API and Event Logic ExplainedIn this guide, you will learn how to bridge the gap between your Lua scripts and physical hardware in OpenComputers by mastering the Component API and the event system. Understanding how component addresses, proxy tables, and event pulling work is essential for automating complex multi-device networks and interacting with other mods via the Adapter.Intermediate7 steps
OpenComputers · AutomationHow to Automate Other Mods with the OpenComputers AdapterIn this guide, you will learn how to use the OpenComputers Adapter and Redstone I/O blocks to read data from external tech mod machines and automatically control them using Lua scripts. Mastering this setup allows you to build smart power grids that toggle generators based on energy storage levels, prevent reactor meltdowns, and coordinate complex factory lines without manual intervention.Intermediate8 steps
OpenComputers · Setup guideHow to Assemble and Program OpenComputers RobotsIn this guide, you will learn how to construct a modular OpenComputers Robot using the Electronics Assembler and program it in Lua to automate resource gathering. Mastering robots allows you to offload tedious tasks like branch mining and crop harvesting to persistent, self-contained machines that interact with the world just like a player.Intermediate8 steps