Create: No Unlimited Energy

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_FLOW bug 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.