TinyRuleKit

Getting Started

Many small engines start with a few direct if statements:

JAVA

void onPlayerJoined(Player player, GameCalendar calendar) {
    if (player.level() >= 5 && player.hasPermission("vip")) {
        player.wallet().addCoins(25);
    }

    if (player.level() >= 10 && player.completedQuest("tutorial")) {
        player.badges().unlock("veteran");
    }

    if (calendar.isWeekend() && player.region() == Region.EU) {
        player.boosts().add("weekend_bonus");
    }
}

That can be fine for three rules. With 30 or 50, the class starts mixing matching logic, parameters, and side effects in one place. Changing an amount, disabling a rule for one environment, or letting a non-engine author adjust a rule usually means touching Java code and redeploying the application.

A heavy weight rules platform can solve that, but often adds more runtime model, syntax, and infrastructure than a small game, tool, or app needs.

TinyRuleKit sits in that middle ground.

What TinyRuleKit Provides

TinyRuleKit lets applications keep domain behavior in Java while moving rule configuration to JSON:

JSON

[
  {
    "id": "vip_join_reward",
    "trigger": "PLAYER_JOINED",
    "conditions": [
      {
        "type": "LEVEL_AT_LEAST",
        "params": {
          "level": 5
        }
      }
    ],
    "actions": [
      {
        "type": "GIVE_COINS",
        "params": {
          "amount": 25
        }
      }
    ]
  }
]

The framework compiles that JSON once into executable Java functions. At runtime, firing a trigger only evaluates rules indexed for that trigger.

JAVA

engine.fire(GameTrigger.PLAYER_JOINED, context);

Basic Shape

The first useful TinyRuleKit setup has four Java pieces:

Token enums for the JSON vocabulary: triggers, conditions, and actions.
A RuleContext that exposes the data rules can read.
A static condition factory that converts condition token names and parameters into CompiledCondition functions.
A static action factory that converts action token names and parameters into CompiledAction functions.

Those pieces are the basic surface of the framework. The JSON does not decide Java behavior by itself; it selects from the enum vocabulary and passes parameters that your factories validate during engine construction.

What Stays In Java

Your application still owns the real behavior:

JAVA

static CompiledAction<GameContext> action(String type, RuleParams params) {
    return switch (RuleToken.enumValue(GameAction.class, type)) {
        case GIVE_COINS -> {
            int amount = params.getInt("amount", 1);
            yield (context, variables) -> context.wallet().addCoins(amount);
        }
    };
}

TinyRuleKit is useful when rules are simple enough to express as triggers, conditions, actions, and parameters, but should remain configurable outside the compiled application.

Move to Setup when you are ready to add TinyRuleKit to a project.

Documentation Packages

01 SetupInstall TinyRuleKit and add it to an application project. 02 Static RulesThe basic Java path: enums, resolver factories, basic JSON, precompilation, and trigger execution. 03 ExpressionsAdvanced optional expressions, custom engines, safe views, and expression security. 04 RuntimeHot reload, required tokens, and framework version constraints. 05 JSON AuthoringOperators, trigger guards, condition definitions, loader hints, and JSON review practices.

Learning Curve

Basic: static rulesStart with enum tokens, static condition/action factories, basic JSON, and the compiled engine model. Basic: RuleParamsValidate typed parameters before applying static-rule best practices. Advanced: expressionsAdd expressions only when static rules are not enough. Required for expressionsUse safe views, minimum protections, and project-owned security components. Runtime: requirementsLearn capability and framework-version requirements before deep JSON authoring. JSON: deep diveCentralized guidance for composed conditions, metadata, loader hints, and reviewable rule files.