Create: No Unlimited Energy (NUE)
Make power in Create something you engineer, not something you plop down.
NUE ties Create's kinetics to genuinely flowing water (Flowing Fluids) and a touch of ComputerCraft, turning energy generation into a real engineering problem: build a hydroelectric dam, a wind farm, and the logic that runs them — instead of a wheel parked in a puddle. Server-authoritative; clients only need the jar to see correct numbers in the goggles.
In action
Goggle readout: available power, rotation speed, and the dam-coherence multiplier (a 9-wheel dam, ×1.40).
A live energy dashboard on a monitor, driven by the cm_generator and cm_meter peripherals.
Wiring ComputerCraft modems to the wheels and gauges (green = a peripheral is attached).
Philosophy
- Free, easy energy is the bug. A wheel in a still pool — or a sealed pump loop — should not power a base. Power has to be earned.
- Water is engineered. Wheels run only on a real current, and output scales with flow strength, the head (how far the water falls onto the wheel) and biome. Strong channels and tall dams are the lever.
- Bigger pays off. Many working wheels clustered into one dam reward super-linearly — a real hydro megastructure beats scattered wheels by more than ×N.
- No perpetual motion. Generating consumes a little water at the intake, so closed pump→wheel loops run dry; only genuine rain / river / ocean sources sustain.
- Wind is variable, not free. A windmill's rotor speed tracks live gusts, weather and the day/night cycle, and its strength depends on placement (open sky, height, biome). Cheap and early — but unreliable.
- Stable water vs gusty wind. Water is the premium, scalable backbone; wind is the convenient, swingy early option. Build both.
- Automate it — optionally. ComputerCraft peripherals expose live telemetry of every wheel, windmill and gauge, so you can build dashboards and control logic in Lua. Never required.
Requirements
| Mod | Role |
|---|---|
| Create (Fabric) 6.x | Required |
| Flowing Fluids | Required — finite, genuinely flowing water. Set create_waterWheelMode = REQUIRE_FLOW. |
| CC: Tweaked | Optional — read-only telemetry peripherals. Everything works without it. |
Fabric Loader ≥ 0.15 · Java 17 or 21.
Languages
In-game text (the goggle readout) is localized:
- 🇬🇧 English (
en_us) — default - 🇷🇺 Русский (
ru_ru) - 🇨🇳 简体中文 (
zh_cn)
Translations welcome — add an assets/create_nue/lang/<locale>.json and open a PR.
Features
Water wheels — flowing water only, and dams pay off
- Real current only. A wheel in still water produces nothing — you build an actual flow. (Also
fixes a Flowing Fluids
REQUIRE_FLOWbug where wheels never registered as flow listeners and stayed dead.) - Power = current strength × head × biome. Tall dams and strong channels are how you scale.
- Megastructure reward. A cluster of generating wheels (a real dam) rewards super-linearly; a dry, fake cluster gains nothing.
- Direction stability. Signed-score hysteresis + shaft consensus stop wheels flickering direction under finite-water churn, so large single-direction arrays are buildable.
- No perpetual motion. A small water-as-fuel tax drains the intake while generating.
- Goggle readout. Wearing Create's goggles on a wheel shows the dam size and its multiplier.
Windmills — variable wind, not a flat number
Two independent quantities (in Create, SU = capacity-per-RPM × RPM):
- Speed (the visible rotor) = how windy it is right now — gusts × weather × day/night, smoothed so the rotor drifts naturally.
- Force (capacity) = the windmill's placement — open-sky exposure × height × region biome.
ComputerCraft (optional)
Attach a wired modem to a wheel, windmill, Stressometer or Speedometer — no new blocks, no hard dependency (the integration only loads when CC is present).
| Peripheral | Methods |
|---|---|
cm_generator (wheels, windmills) |
kind(), active(), capacity(), rpm(), stress(), info() |
cm_meter (Stressometer, Speedometer) |
gaugeType(), speed(), capacity(), stressUsed(), load(), overstressed() |
-- print every NUE generator + gauge on the wired network
for _, n in ipairs(peripheral.getNames()) do
local t = peripheral.getType(n)
if t == "cm_generator" then local g = peripheral.wrap(n)
print(n, g.kind(), g.active(), g.stress() .. "SU", g.rpm() .. "rpm")
elseif t == "cm_meter" then local m = peripheral.wrap(n)
print(n, m.gaugeType(), m.stressUsed() .. "/" .. m.capacity() .. "SU", math.floor(m.load()*100) .. "%")
end
end
Configuration
Generated at config/create_nue.json on first launch — every value is tunable (flow/head/biome curves, the
dam-coherence reward, the water tax, the full wind model, the per-wheel SU cap). Delete it to regenerate.
Building from source
Loom + Mojang mappings, compiled for Java 17 (runs on 17 or 21). The compile-time dependencies (Create,
Flowing Fluids, CC: Tweaked, and the fabric-api-lookup-api-v1 module) are not redistributed — drop
their jars into libs/, then:
./gradlew build # -> build/libs/create-nue-<version>.jar
Roadmap
NUE is an ongoing answer to "free, easy energy in Create is silly." Generation is being deepened while RF/electricity and storage stay a normal progression tier — the aim is to make a huge hydro dam the most rewarding way to make electricity, with water wheels and windmills as the mechanical base the whole energy economy is built on. Planned: a profitable-generation economy hook, pumped-hydro storage, seasonal water/wind, and richer ComputerCraft telemetry.
Contributing
Build, architecture, mixin conventions, localization, and the release process are documented in
AGENTS.md. Translations and PRs welcome.
License
MIT. Contributions and forks welcome.
