m210.duke4.net Paid content

eDuke32 is a source port of the Build engine, the technology behind Duke Nukem 3D and several other 1990s first-person shooters. It runs the original game data you already own while replacing the old DOS executable with a modern engine that adds widescreen rendering, high-resolution texture and 3D model support, improved audio, and scripting. You need it if you want to play Duke Nukem 3D or its user-made maps and mods on a current system without relying on DOSBox. It is not the same thing as BuildGDX, a separate Java-based port from M210 Projects that targets a different set of Build titles.

What eDuke32 actually is

The Build engine was licensed to multiple studios, so "Build games" is a family rather than a single title. eDuke32 focuses on the Duke Nukem 3D branch of that family. Like other source ports, it does not ship the commercial game assets. You supply the original data files (for Duke Nukem 3D, the .GRP file from your copy of the game), and the port loads them.

Because the engine is open and extensible, eDuke32 became the standard way to run:

• The original Duke Nukem 3D episodes
• User-made single maps and full episode replacements
• Total conversions and gameplay mods
• Projects that rely on extended scripting beyond what the 1996 executable allowed

What it adds over the original DOS version

The original executable was limited by 1996 hardware and DOS conventions. A source port lifts those limits. Typical gains include:

• Display: widescreen aspect ratios, higher internal resolutions, and support for high-resolution texture packs.
• Geometry and models: 3D model replacements for sprites, and rendering features the original renderer could not do.
• Audio: modern sound output and music handling instead of period-correct DOS audio paths.
• Content pipeline: scripting and definition files that let mod authors add behavior the original engine had no concept of.
• Editing: a built-in map editor and the tooling modders use to build and test levels.

The practical effect is that a 1996 game can run at modern resolutions with community-made visual and audio upgrades, while still playing the original maps.

eDuke32 vs. BuildGDX

These are two different ports with different scopes, and the distinction matters when you are choosing what to install.

BuildGDX is maintained by M210 Projects, whose site also lists related work such as BloodCM and ports for Unreal and Unreal Tournament. Its release notes show active development: version 1.17 (23 August 2024) raised the Java requirement to JRE 8, added raw mouse input, a new controller input logic, drag-and-drop map file loading, a new sound manager with an OpenAL driver, a new console, and a new file handler system. Version 1.18 (11 January 2025) added bilinear filtering for palette emulation, a palette emulation soft shading option, XInput gamepad support on Windows, and a range of crash and platform fixes, including OSX sky rendering and resolution changes.

If your goal is Duke Nukem 3D specifically, eDuke32 is the conventional choice. If you want to run Blood, Shadow Warrior, or several Build games through one launcher, BuildGDX is built for that. The two are not interchangeable, and installing one does not give you the other's game support.

What you need before you start

• A legitimate copy of the game. The port does not include the copyrighted data. For Duke Nukem 3D you need the original game files.
• The correct data file for your title. Duke Nukem 3D uses its .GRP file; other Build games use their own data files, which is one reason a single port cannot cover all of them identically.
• A place to put mods. Most mods are distributed as folders or archives that the port loads alongside or instead of the base game data.

Common points of confusion

• "Source port" does not mean "free game." The engine code is separate from the game assets. You still need the game.
• A port is not an emulator. eDuke32 reimplements the engine natively rather than emulating DOS, which is why it can add features the original never had.
• Mod compatibility is not universal. Mods written for one port's extended scripting may not run on another, and BuildGDX's own notes record that its savegame version changed between releases, so saves are not always portable across versions.
• BuildGDX is not a Duke Nukem 3D replacement for eDuke32. It supports Duke Nukem 3D, but its design goal is breadth across Build titles rather than depth in the Duke modding scene.

If you are deciding between them, the question to answer first is which game you actually want to run. That single answer usually settles the choice.

Poly Haven is a public 3D asset library offering models, textures, and HDRIs under CC0, which means you can use them in commercial Unreal Engine projects without attribution or licensing fees. To get them working, you need to match the right download format to the right Unreal import path: FBX for models, PNG or JPG for textures, and EXR or HDR for lighting. This guide covers the full workflow from search to a lit scene, plus the import problems that trip people up most often.

What Poly Haven Offers for Unreal Projects

The library is organized into three asset types, and each maps to a different part of an Unreal scene:

Because everything is CC0, the license question is settled before you start: no attribution required, no restrictions on commercial use. That makes Poly Haven a practical first stop for game prototypes and arch-viz scenes where you want to move fast without tracking licenses.

Finding the Right Assets

Search by the role the asset plays in your scene rather than by name. For a game environment, you might search for a specific prop category; for arch-viz, you might search for a material type or an HDRI that matches the time of day you're lighting for.

Two habits save time later:

• Check the resolution options before downloading. Textures and HDRIs are usually offered at several resolutions. Pick the lowest one that holds up at your target camera distance — a 1K texture on a background prop is often indistinguishable from 4K and far cheaper on memory.
• Download the full PBR set for textures, not just the base color. A base color map alone will look flat. You want the accompanying normal, roughness, and ambient occlusion maps so the material responds correctly to light.

For models, confirm the format list on the asset page. FBX is the safest choice for Unreal because the importer handles it natively and preserves the material slot structure.

Importing Models

1. Download the FBX from the asset page.
2. Drag the file into the Content Browser, or use the Import button. Unreal will open the FBX Import Options dialog.
3. Set the import settings. For static props, leave the default static mesh import. Check that "Import Materials" is enabled if you want Unreal to generate placeholder materials from the FBX's material slots.
4. Confirm scale. Poly Haven models are typically authored at real-world scale in meters. Unreal's default unit is centimeters, and the FBX importer applies a conversion automatically. If a model comes in visibly too large or too small, this conversion is the first thing to check — see the troubleshooting section below.

After import, the mesh appears in the Content Browser. Drag it into the level to place it.

Setting Up Materials on Imported Models

The materials Unreal generates from an FBX are usually placeholder-quality. To get the intended look:

1. Create a new Material (or Material Instance) in the Content Browser.
2. Add texture sample nodes for each map you downloaded — base color into Base Color, normal into Normal, roughness into Roughness, and so on.
3. Assign the material to the mesh's material slots.

If the model has multiple material slots (common for props with distinct surface types), you'll repeat this per slot.

Importing Textures and Building Materials

Textures import as Texture assets. Drag them into the Content Browser and Unreal handles the rest, but two settings matter:

• sRGB. Base color maps should have sRGB enabled. Normal, roughness, and other data maps should have sRGB disabled, or the values will be interpreted as color and the material will look wrong.
• Compression. The default compression is fine for most cases. For normal maps, Unreal usually detects the correct setting from the texture name or you can set it manually.

Once imported, wire the textures into a material as described above. For a tiling surface, set the texture's sampler to wrap and use a TextureCoordinate node to control tiling scale.

Setting Up HDRI Lighting

HDRIs are the fastest way to get believable lighting in an Unreal scene, and this is where the EXR/HDR format matters.

1. Download the HDRI at a resolution appropriate to your needs. Higher resolutions give sharper reflections; lower resolutions are lighter.
2. Import the EXR or HDR into Unreal. It becomes a Texture asset.
3. Create a Sky Light in the level and set its source type to use the HDRI texture (via a cubemap or the Sky Light's cubemap slot, depending on your Unreal version's workflow).
4. Optionally add a Sky Atmosphere or background sphere with the HDRI mapped to it so the sky is visible, not just the lighting.

The HDRI drives ambient light and reflections. If your scene looks flat after adding a Sky Light, check that the HDRI texture actually imported with the correct color depth — an 8-bit import of an HDR file will lose the highlight range that makes HDRI lighting useful.

Licensing: What CC0 Means Here

CC0 places the work in the public domain. For Unreal projects, that means:

• Commercial use is allowed — you can ship a game or client arch-viz project using these assets.
• No attribution is required, though crediting Poly Haven is a reasonable courtesy.
• No derivative restrictions — you can modify, retexture, and redistribute the assets as part of your project.

The one thing CC0 does not do is guarantee that a given asset is free of other claims (for example, a scanned object that itself has trademark protection). For ordinary props, materials, and HDRIs, this is rarely a practical concern, but it's worth knowing the distinction between a permissive license and a legal clearance.

Troubleshooting Common Import Issues

Model comes in at the wrong scale

This is the most common FBX import problem. Causes and fixes:

• Unit mismatch. If the FBX was authored in meters and Unreal interprets it as centimeters (or vice versa), the model will be off by a factor of 100. Check the FBX Import Options for the "Convert" or scale setting and adjust.
• Non-uniform scale in the source. If the model was scaled non-uniformly before export, it can import distorted. Re-export from the source at uniform scale if possible.

Textures look wrong or washed out

Almost always an sRGB setting. Base color maps need sRGB on; data maps (normal, roughness, metallic, AO) need it off. Fix it in the Texture asset's details panel and the material will update.

HDRI lighting looks flat

Either the HDRI imported at reduced bit depth, or the Sky Light isn't set to use it as a cubemap source. Verify the texture's imported format and the Sky Light's source setting.

Missing textures after import

Unreal doesn't automatically find textures referenced by an FBX unless they're in the expected relative path. The reliable fix is to import textures manually and wire them into materials yourself, which also gives you control over sRGB and compression settings.

A Practical Starting Order

For a new scene, this sequence avoids rework:

1. Pick and import your HDRI first — it sets the lighting mood everything else is judged against.
2. Import models and place them roughly.
3. Import textures and build materials, then assign them.
4. Adjust lighting and exposure last, once the materials are correct.

Working in this order means you're not re-tuning lighting every time a material changes.

BuildGDX is a Java-based port of the Build engine that runs classic games such as Blood, Duke Nukem 3D, Shadow Warrior, Redneck Rampage, Witchaven and Tekwar. BloodGDX is the Blood-specific component of that project. To play Blood with it, you supply your own copy of the original Blood game data and run it through the port rather than through the original DOS executable. The current release listed on the M210 Projects site is BuildGDX v1.18 (11.01.2025), which includes several Blood-specific fixes.

What BuildGDX Is and Where Blood Fits

BuildGDX is described on the site as "the port of Blood, Duke3D, Shadow Warrior, Redneck Rampage, Witchaven, Tekwar, etc." Each supported game has its own launcher component — BloodGDX for Blood, DukeGDX for Duke Nukem 3D, and so on. The shared BuildGDX layer handles rendering, input, audio and configuration; the game-specific layer handles that title's data and behaviour.

This matters for Blood because the port is not a standalone free game. You still need the original Blood data files. The port provides the engine and compatibility layer, not the game content.

What You Need Before You Start

• The original Blood game data files.
• A Java runtime. BuildGDX v1.17 raised the Java requirement to JRE 8, so a Java 8 or newer runtime is needed for current versions.
• The BuildGDX release package from the M210 Projects downloads section.

The site does not state a price for BuildGDX, and no pricing links appear on the page. A PayPal payment platform is referenced on the site, but the page evidence does not describe what it is used for, so no assumption should be made about cost or licensing from that alone.

Features Relevant to Blood

The v1.18 changelog lists changes that affect the whole BuildGDX family, plus a Blood-specific entry.

General BuildGDX features in v1.18

Blood-specific fix in v1.18

• Fixed loading extra data in savegame files, following the earlier removal of support for old DOS saves.

That last point is the one to remember if you are carrying saves forward: old DOS-format saves are no longer supported, and v1.18 corrects a problem with loading the extra data in the newer save format.

Setting It Up

1. Install a Java 8 or newer runtime.
2. Obtain the BuildGDX release from the M210 Projects downloads section.
3. Place your original Blood data files where the port expects them.
4. Launch the BloodGDX component.
5. Open the configuration and adjust the options you care about — palette emulation, bilinear filtration, mouse sensitivity, and controller input if you are on Windows.
6. Start a game and confirm rendering and audio behave as expected.

The site does not document the exact folder layout or menu paths, so treat the placement step as "follow the release's own instructions" rather than a fixed path.

Version History and What Changed

The site lists these BuildGDX releases:

• v1.18 — 11.01.2025
• v1.17 — 23.08.2024
• v1.16 — 05.12.2021
• v1.15 — 17.08.2020
• v1.14 — 26.07.2020

v1.17 was a large internal overhaul. The changelog notes raw mouse input, new controller input logic, drag-and-drop map file support, a new sound manager, a new OpenAL audio driver (1.23), a new console, a new input processor, a new file handler system, a new renderer changer, a new config file version, and a savegame version increase. The author states that the release "doesn't contain all what I wanted to change" and that the changelog may be incomplete.

Two consequences follow from v1.17 that affect Blood players:

• Savegames are not compatible with older BuildGDX versions. The savegame version was increased.
• The config file version changed, so settings may need to be recreated.

Troubleshooting Common Problems

Saves won't load. Old DOS saves are no longer supported. If you are on v1.18, the extra-data loading fix should help with saves made in the current format. If you upgraded from a pre-v1.17 build, expect old saves not to carry over.

Crash when deleting all saves and saving a new one. This was fixed in v1.18.

Crash with a single demo in "randomly" playback mode. Fixed in v1.18.

Renderer crash on a map with broken sectors. Fixed in v1.18 for the Polygdx renderer.

Resolution won't apply. The software renderer rejects resolutions above 4096x3072.

Audio exceptions. v1.18 makes Midi isOpen() check the sequencer to avoid an exception.

macOS input or sky rendering problems. v1.18 changed the input method algorithm in an attempt to fix macOS input, and fixed macOS sky rendering and resolution changing.

Choosing Whether to Use It

Use BuildGDX for Blood if you want a modernised way to run the original game with controller support, configurable mouse sensitivity, palette emulation options and ongoing fixes. Stay on an older build only if you depend on saves or a config from before v1.17 — and in that case, note that you will miss the v1.18 Blood savegame fix. If you are starting fresh, v1.18 is the version the site currently lists.

M210 Projects is the home of BuildGDX, a Java-based source port that runs classic Build engine games such as Blood, Duke Nukem 3D, Shadow Warrior, Redneck Rampage, Witchaven, and Tekwar on modern systems. If you want to play those games with updated input, rendering, and audio support, this is the project to look at. The site also covers maps and mods for eDuke32, Unreal, Unreal Tournament, Serious Sam, and Half-Life, and it hosts release notes, downloads, a forum, and a Discord server.

What BuildGDX actually is

BuildGDX is a port of the Build engine games, written in Java and built on libGDX. Rather than emulating the original executables, it reimplements the engine so the games can run natively on current hardware and operating systems.

The port covers several games under one project, with per-game components named after their titles:

• BloodGDX – Blood
• DukeGDX – Duke Nukem 3D
• WangGDX – Shadow Warrior
• DK / RR – Redneck Rampage titles
• TekwarGDX – Tekwar
• LSPGDX – Witchaven

Because it is Java-based, BuildGDX requires a Java runtime. The v1.17 release notes state that the Java code level was increased to version 8, so JRE 8 is required from that version onward.

What changed in recent versions

The download page lists version histories with dated release notes. The most recent entry is BuildGDX v1.18 (11.01.2025), which includes:

• Bilinear filtration for palette emulation mode
• A palette emulation soft shading option
• XInput gamepad support (Windows only)
• Updated libraries: libgdx 1.13.0, jinput 2.0.10, lwjgl 3.3.3
• Mouse sensitivity changed from a 0–2 slider to a text field
• useHighTiles and useModels default back to true for new configs (affects skyboxes)
• Multiple crash fixes, including deleting all save files then saving a new one, and loading maps with broken sectors
• Software renderer resolution check: resolutions larger than 4096x3072 are not supported
• OSX sky rendering and resolution changing fixes

The previous major release, BuildGDX v1.17 (23.08.2024), was a larger overhaul. Its notes mention raw mouse input, a new controller input logic, drag-and-drop map file support, a new sound manager and OpenAL driver 1.23, a new console, a new input processor, a new file handler system, and a new renderer changer. Importantly, it also notes that the savegame version was increased and is not compatible with older BuildGDX saves, and that the config file version changed.

Older entries on the page go back to v1.14 (26.07.2020), so you can trace how the port evolved if you need to match a specific version.

How to get started

1. Go to the Main Downloads section of the site.
2. Pick the BuildGDX version you want. If you are starting fresh, the latest release is the natural choice; if you need compatibility with existing saves or configs, check the version notes first.
3. Make sure you have a Java runtime installed. For v1.17 and later, that means JRE 8 or newer.
4. Install the port and point it at your game data. BuildGDX is a port, not a game distribution — you still need the original game files.
5. Use the in-game console and configuration options to adjust rendering, input, and audio to your setup.

If you run into problems, the site links to a forum and a Discord server where the project is discussed.

Beyond BuildGDX

The site's scope is wider than one port. Its title and keywords reference eDuke32, Unreal, Unreal Tournament, Serious Sam, and Half-Life, along with maps and mods for those games. So if you came for Duke Nukem 3D mapping or Unreal content, there may be relevant material here beyond the BuildGDX downloads.

Supporting the project

The site lists PayPal as a payment platform, so you can support development financially if you want to. There is no indication on the page that any of the downloads are paid or require login — but the page evidence does not state download terms explicitly, so treat availability as something to confirm on the site itself.

Quick reference

If your goal is to run a classic Build engine game on a modern machine, start with the latest BuildGDX release and confirm you have JRE 8 or newer. If your goal is mapping or modding for the other listed games, browse the downloads and forum sections for the relevant title.

Minecraft mods are community-made additions that change the game — adding new blocks, mobs, biomes, tools, or improving performance and interface. To use them, you need a mod loader (such as Fabric, Forge, or NeoForge) that matches your game version, and you need to match each mod's supported version and loader before installing. This guide covers what mods are, how they relate to loaders and modpacks, how to find them, and how to install and troubleshoot them.

What Mods, Mod Loaders, and Modpacks Actually Are

These three terms get mixed up constantly, so it helps to separate them:

• Mod — a single modification. One mod might add a minimap; another might optimize chunk rendering.
• Mod loader — the framework that lets mods run at all. Fabric, Forge, and NeoForge are the common ones. A mod built for Fabric generally will not run on Forge, and vice versa.
• Modpack — a curated bundle of many mods, usually pre-configured to work together, often distributed through a launcher.

The practical consequence: when you download a mod, you are choosing a loader and a game version, not just a feature. A mod page will list something like "Fabric 1.20.1" — that is the combination you must match.

Common Types of Mods by Purpose

Most mods fall into a few broad categories, which is useful when you are browsing a large list and want to filter by intent rather than name.

That last row matters more than it looks. Many mods will not run on their own — they depend on a library mod, and if you skip it, the game crashes or the mod silently fails to load.

How to Find Mods and Check Compatibility

A searchable mod list is the fastest starting point. FiberMC, for example, describes itself as "a searchable list of (almost) all Minecraft Fabric mods," and its interface exposes sort and filter controls including Name, Author, Downloads, Latest Supported Version, and Date Updated, plus a Categories filter and a table view.

When you are looking at any mod listing, check these before downloading:

1. Loader — does it say Fabric, Forge, or NeoForge? Match it to your setup.
2. Game version — does it support the exact Minecraft version you run? "1.20" and "1.20.1" are not always interchangeable.
3. Dependencies — does the description list required library mods?
4. Last updated — a mod that has not been updated for your version may still work, but it is a risk signal.
5. Downloads / popularity — useful as a rough signal, not a guarantee of quality.

Sorting by Latest Supported Version or Date Updated is a quick way to surface mods that are actually current for your game version, rather than ones that stopped being maintained a year ago.

Installing Mods: The Basic Steps

The exact clicks depend on your launcher, but the logic is consistent:

1. Install a mod loader for your Minecraft version (Fabric, Forge, or NeoForge) and create a profile for it in your launcher.
2. Locate your mods folder — usually .minecraft/mods for that profile.
3. Download the mod file that matches your loader and game version (typically a .jar).
4. Place the .jar into the mods folder. Do not unzip it.
5. Download and add any required dependencies the same way.
6. Launch the game using the modded profile, not the vanilla one.

Expected result: the game starts with the mod active. If it does not, the next section is where to look.

Troubleshooting Crashes and Conflicts

Most mod problems come down to a small set of causes:

• Wrong loader — a Forge mod in a Fabric profile will fail.
• Wrong game version — the mod targets a version your loader profile is not running.
• Missing dependency — a required library mod is absent.
• Two mods conflicting — two mods change the same thing (for example, both overhaul the same UI screen).
• Outdated mod — it worked on an older version but breaks on the current one.

A practical approach: add mods in small batches rather than all at once, so when something breaks you know which addition caused it. Read the crash log — it usually names the failing mod or the missing dependency directly.

Why Multiplayer Needs Matching Mods

On a server, mods generally need to be present on both the server and the client for the features to work, because the server and client each run their own copy of the game logic. Some mods are server-side only (they change server behavior without requiring clients to install anything), and some are client-side only (like a minimap), but many content mods require both sides to match. If a server runs a mod the client does not have, the client may be rejected or the feature may not function. This is also why modpacks are popular for multiplayer — everyone installs the same bundle, so versions and dependencies line up automatically.

Quick Decision Guide

• Just want better performance? Look for performance-category mods matching your loader and version.
• Want new content? Check content-expansion mods, and expect to install dependencies.
• Playing with friends? Use a shared modpack so server and client match.
• Not sure a mod is current? Sort by latest supported version or date updated, and confirm the loader and game version before downloading.