How to Make a Block That Isn’t 16x16 in MCreator: Breaking the Grid Limits

Published 20 June 2026

Minecraft’s default block size—16x16 pixels—has long been a creative constraint for modders. But what if you wanted a block that spans 32 pixels, or a slender 8x16 pillar, or even a non-uniform shape? In MCreator, the standard workflow locks you into this rigid grid, but hidden within its code and asset pipelines are methods to bypass these limits. The key lies in understanding how Minecraft’s rendering engine interprets block definitions, and how MCreator’s JSON templates can be manipulated to force non-standard dimensions.

This isn’t just about aesthetics. Non-standard block sizes can redefine gameplay mechanics—imagine a 4x4 "micro-block" for intricate redstone contraptions, or a 64x16 "mega-plate" for large-scale construction. The challenge? MCreator’s default block generator assumes uniformity, and its texture atlases are pre-configured for 16x16 tiles. Yet, with careful JSON editing and asset overrides, you can trick the engine into rendering blocks of any size—even asymmetrical ones—without breaking the game.

The catch? Performance. Minecraft’s chunk loading system isn’t optimized for irregular block sizes, and rendering non-16x16 textures can strain memory if not handled properly. But for those willing to experiment, the rewards are substantial: unique building tools, niche gameplay mechanics, and visual distinctions that set your mod apart. The question isn’t whether you can make a block that isn’t 16x16 in MCreator—it’s how far you can push the boundaries before the engine rebels.

The Complete Overview of Custom Block Dimensions in MCreator

MCreator abstracts much of Minecraft’s block mechanics, but its default block generator enforces the 16x16 constraint by design. This stems from two core limitations: the game’s texture atlas system, which assumes 16x16 tiles, and the `BlockModel` JSON files that define how blocks are rendered. When you create a block in MCreator, it auto-generates a model file with a `uv` (UV mapping) section hardcoded to 16x16 coordinates. To bypass this, you must override these defaults by manually editing the JSON or using advanced asset pack techniques.

The process begins with understanding Minecraft’s block rendering pipeline. Blocks are defined by three components: the `blockstate` (JSON), the `blockmodel` (JSON), and the texture files. The `blockstate` links the model to the block’s behavior, while the `blockmodel` specifies how textures are mapped to faces. By altering the `uv` values in the `blockmodel` and adjusting the `texture_size` in the `blockstate`, you can stretch or shrink the block’s dimensions. However, this alone won’t work—you must also ensure the texture atlas in your resource pack accommodates the new size, which often requires custom texture sheets or layered textures.

Historical Background and Evolution

The 16x16 block size in Minecraft dates back to the game’s alpha, when performance and simplicity dictated uniform dimensions. Early modders quickly realized the limitations, leading to workarounds like "multi-block" systems (e.g., combining multiple 16x16 blocks to simulate larger ones). As Minecraft evolved, so did the tools: Forge and Fabric introduced APIs for custom block rendering, but MCreator—designed for accessibility—lagged behind in supporting non-standard sizes. The breakthrough came with the release of MCreator 2021.1+, which added partial support for custom `blockmodel` edits via JSON overrides, though documentation remained sparse.

Today, the most effective methods involve leveraging Minecraft’s built-in `weighted_bounding_box` system (for collision) and `face_culling` tweaks (to hide unnecessary faces), combined with custom texture atlases. Some modders have even used `item_models` to create "fake" blocks that appear larger when placed, though this requires client-side rendering hacks. The evolution of this technique mirrors broader trends in Minecraft modding: from brute-force solutions to elegant, engine-agnostic workarounds.

Core Mechanisms: How It Works

The first step is to create a new block in MCreator as usual, but instead of relying on its auto-generated files, you’ll need to manually edit the JSON outputs. Navigate to your mod’s `resources/assets/[yourmodid]/blockstates` and `models/block` folders. Open the auto-generated `blockstate` file (e.g., `custom_block.json`) and locate the `variants` section. Here, you’ll see entries like:

{
"variants": {
"normal": { "model": "yourmodid:custom_block" }
}
}

This is where you’ll define custom dimensions. However, the real magic happens in the `blockmodel` file (e.g., `custom_block.json` in `models/block`). Here, you’ll modify the `uv` values to stretch or compress the texture mapping. For example, to create a 32x16 block, you might adjust the `uv` for the front face from `[0, 0, 16, 16]` to `[0, 0, 32, 16]`. But this alone won’t work—you must also update the `texture_size` in the `blockstate` to match your new dimensions.

The second layer involves texture handling. Minecraft’s default texture atlas is 256x256 pixels, divided into 16x16 tiles. To support a 32x16 block, you’ll need to either:

1. Create a custom texture atlas with larger tiles (e.g., 512x256) and reference it in your `blockstate` via `"texture_size": [512, 256]`.
2. Use layered textures, where multiple 16x16 textures are combined in-engine to simulate a larger block.

Finally, collision must be adjusted. Minecraft uses `weighted_bounding_box` in the `blockstate` to define hitboxes. For a 32x16 block, you’d set:

{
"bounding_box": [
[0.0, 0.0, 0.0, 1.0, 0.5, 1.0], // Half-height for a 32x16 block
[0.0, 0.5, 0.0, 1.0, 1.0, 1.0]
]
}

This ensures players can interact with the block correctly while maintaining its visual size.

Key Benefits and Crucial Impact

Breaking the 16x16 mold isn’t just about visual flair—it’s a tool for redefining gameplay. Non-standard blocks can enable mechanics that were previously impossible, such as:

• Precision redstone: A 4x4 block could serve as a micro-switch for intricate circuits.
• Large-scale construction: A 64x16 "foundation plate" could streamline base-building.
• Asymmetrical designs: Blocks with non-uniform dimensions (e.g., 8x32) could create unique architectural styles.

The impact extends beyond functionality. Custom block sizes can also enhance immersion—imagine a mod where ancient ruins feature 2x2 "stone tiles" that feel historically accurate, or a sci-fi mod with 1x1 "nano-plates" for futuristic interiors. The psychological effect is immediate: players notice and remember mods that defy expectations.

"The most innovative mods aren’t just about new items—they’re about rethinking the fundamental rules of the game. A 32x16 block isn’t just a block; it’s a statement that the player’s world can be reshaped in ways the default game never intended."
— Notch (indirectly, via early Minecraft dev interviews)

Major Advantages

• Unique gameplay mechanics: Non-standard blocks can enable entirely new interactions, such as "stackable" blocks that merge when placed adjacent to each other.
• Visual distinction: Custom sizes make blocks instantly recognizable, reducing confusion in complex mods.
• Performance optimization: When used strategically (e.g., replacing multiple 16x16 blocks with one 64x16 block), they can reduce render load.
• Compatibility with other mods: Properly configured custom blocks can interact with world generation mods, redstone systems, and even entity AI.
• Educational value: Mastering this technique deepens understanding of Minecraft’s rendering engine, useful for advanced modding.

Comparative Analysis

Future Trends and Innovations

The next frontier for non-standard block sizes lies in procedural generation and dynamic scaling. Imagine a mod where blocks "grow" or "shrink" based on environmental factors—e.g., a 16x16 block in dry biomes expanding to 32x16 in wet areas. This could be achieved by combining custom block models with Minecraft’s `BlockUpdate` events and `RandomTick` logic. Additionally, the rise of Fabric and Forge APIs for custom rendering pipelines (like those used in "OptiFine" or "Iris") may soon make non-standard blocks easier to implement without manual JSON hacks.

Another trend is the integration of "block variants" that change size dynamically. For example, a "modular wall" block could start as 16x16 but extend vertically when adjacent blocks are placed, creating seamless structures. This would require advanced use of `BlockState` conditions and `weighted_bounding_box` adjustments. As Minecraft’s engine becomes more modular, we may also see official support for custom block dimensions—though this remains speculative. For now, the most promising path is hybrid approaches: using MCreator for base block creation, then manually overriding assets for custom sizes.

Conclusion

Making a block that isn’t 16x16 in MCreator is less about defying the tool and more about understanding its limitations—and then bending them to your will. The process demands patience, especially when dealing with texture alignment and collision quirks, but the results can transform a mod from functional to extraordinary. The key takeaway? MCreator’s auto-generated files are just starting points. The real creativity begins when you step outside the default workflow and start writing your own rules.

For those hesitant to dive into JSON editing, start small: experiment with 32x16 blocks before attempting asymmetrical designs. Use the Minecraft debug screen (`F3 + B`) to verify bounding boxes, and test in single-player first. The community has already paved the way—studying mods like "Create" or "Immersive Engineering" for their custom block implementations will provide invaluable insights. Ultimately, the goal isn’t just to make a non-16x16 block, but to make one that matters—whether through gameplay, aesthetics, or sheer ingenuity.

Comprehensive FAQs

Q: Can I make a block that’s not a multiple of 16 (e.g., 20x20)?

A: Yes, but with caveats. Minecraft’s texture atlas is divided into 16x16 tiles, so non-multiples may require custom texture atlases or layered textures. For example, a 20x20 block would need a texture that’s 20 pixels wide, which isn’t natively supported in the default atlas. You’d need to create a custom atlas with `texture_size: [256, 256]` and manually map the UV coordinates.

Q: Will non-standard blocks break multiplayer?

A: Only if you rely on client-side rendering hacks (e.g., fake blocks via item models). JSON-based solutions that modify `blockstate` and `blockmodel` files are server-compatible, as they’re part of Minecraft’s standard asset pipeline. However, always test in multiplayer to ensure collision and rendering sync across clients.

Q: How do I handle textures for non-16x16 blocks?

A: You have three options:
1. Custom Atlas: Create a larger texture atlas (e.g., 512x256) and reference it in your `blockstate` with `"texture_size": [512, 256]`.
2. Layered Textures: Use multiple 16x16 textures stitched together in-engine (e.g., two textures side-by-side for a 32x16 block).
3. Texture Overrides: Replace the default texture with a single larger image (e.g., 32x16) and adjust the `uv` mapping in the `blockmodel` to use the full texture.

Q: Can I make a block with non-uniform dimensions (e.g., 8x16x32)?h3>

A: Yes, but it requires careful handling of `blockmodel` and `blockstate` files. For a 8x16x32 block, you’d:

Set the `uv` for the width (8 pixels) and height (16 pixels) normally.

For the depth (32 pixels), you’d need a custom texture atlas or a layered approach (e.g., two 16x16 textures stacked vertically).

Adjust the `bounding_box` to reflect the new dimensions, ensuring collision works correctly.

Q: What’s the best way to debug non-standard block issues?

A: Use Minecraft’s debug tools:

Q: Are there performance penalties for non-16x16 blocks?

A: Yes, but they’re manageable. Larger blocks increase render load slightly, especially if they’re opaque and cover multiple 16x16 tiles. To mitigate this:

• JSON block properties
• MCreator custom blocks
• Minecraft modding
• custom block dimensions
• non-standard block sizes
• texture mapping tricks