wildling

Website · Syntax · Sandbox · Cookbook · Contributing

Pattern-based string generator — library and CLI in many languages, one shared grammar. Enumerate combinations for wordlists, domain brainstorming, test data, and similar tasks.

Requirements: Docker for language builds; Node 18+ only for the JavaScript port and the documentation site.

Website

Docs and a live browser sandbox are published with GitHub Pages:

• Home (language wall)
• Pattern syntax
• Sandbox
• Cookbook

Build the site locally with ./scripts/build-site.sh (output in _site/). In the repo Settings → Pages, set the source to GitHub Actions.

Install

Pick a published channel when you can; otherwise clone and build that language directory.

Channel	Install
npm	npm install wildling
PyPI	pip install wildling
crates.io	cargo install wildling
Go	go get github.com/dotmonk/wildling/go/v2@latest
NuGet	dotnet tool install -g DotMonk.Wildling

More registries (Maven, Packagist, RubyGems, pub.dev, Hex, LuaRocks, …) and git-only ports are listed on the website language wall and in each <language>/README.md.

Status

Language	Library	CLI
JavaScript / TypeScript	Yes	Yes
Python	Yes	Yes
Java	Yes	Yes
C#	Yes	Yes
Visual Basic / VB.NET	Yes	Yes
C++	Yes	Yes
PHP	Yes	Yes
C	Yes	Yes
Go	Yes	Yes
Rust	Yes	Yes
Kotlin	Yes	Yes
Ruby	Yes	Yes
Swift	Yes	Yes
Scala	Yes	Yes
Dart	Yes	Yes
POSIX shell	Yes	Yes
PowerShell	Yes	Yes
Lua	Yes	Yes
Assembly (x86-64 NASM)	Yes	Yes
R	Yes	Yes
Groovy	Yes	Yes
Perl	Yes	Yes
Elixir	Yes	Yes
Pascal / Free Pascal	Yes	Yes
Zig	Yes	Yes
Fortran	Yes	Yes
Ada	Yes	Yes
F#	Yes	Yes
Haskell	Yes	Yes

Quick start (JavaScript)

cd javascript && npm ci --include=dev && npm run build
./bin/wildling "Year 19##"

Year 1900
Year 1910
…
Year 1999

As a library (from this repo):

const createWildling = require("./javascript/dist/index.js").default;

const wildling = createWildling({
  patterns: ["Year 19##"],
  dictionaries: {},
});

let value;
while ((value = wildling.next()) !== false) {
  console.log(value);
}

Quick start (Python)

cd python && ./build.sh
./bin/wildling "Year 19##"

from wildling import create_wildling

wildling = create_wildling(patterns=["Year 19##"])
value = wildling.next()
while value is not False:
    print(value)
    value = wildling.next()

Quick start (Java)

cd java && ./build.sh
./bin/wildling "Year 19##"

import wildling.Wildling;
import java.util.List;

Wildling wildling = Wildling.create(List.of("Year 19##"));
Object value = wildling.next();
while (!Boolean.FALSE.equals(value)) {
    System.out.println(value);
    value = wildling.next();
}

Quick start (C#)

cd csharp && ./build.sh
./bin/wildling "Year 19##"

using WildlingLib;

var wildling = Wildling.Create(new[] { "Year 19##" });
object value = wildling.Next();
while (value is not false)
{
    Console.WriteLine(value);
    value = wildling.Next();
}

Quick start (Visual Basic / VB.NET)

cd visualbasic && ./build.sh
./bin/wildling "Year 19##"

Imports WildlingLib

Dim wildling = Wildling.Create({"Year 19##"})
Dim value As Object = wildling.Next()
While Not (TypeOf value Is Boolean AndAlso Not CBool(value))
    Console.WriteLine(value)
    value = wildling.Next()
End While

Quick start (C++)

cd cpp && ./build.sh
./bin/wildling "Year 19##"

#include "wildling.hpp"
#include <iostream>

wildling::Dictionaries dictionaries;
wildling::Wildling w({"Year 19##"}, dictionaries);
auto value = w.next();
while (value.has_value()) {
    std::cout << *value << '\n';
    value = w.next();
}

Quick start (PHP)

cd php && ./build.sh
./bin/wildling "Year 19##"

<?php
require 'php/bootstrap.php';

use Wildling\Wildling;

$wildling = Wildling::create(['Year 19##']);
$value = $wildling->next();
while ($value !== false) {
    echo $value, "\n";
    $value = $wildling->next();
}

Quick start (C)

cd c && ./build.sh
./bin/wildling "Year 19##"

Quick start (Go)

cd go && ./build.sh
./bin/wildling "Year 19##"

import "github.com/dotmonk/wildling/go/v2/wildling"

w := wildling.New([]string{"Year 19##"}, nil)
for {
    value, ok := w.Next()
    if !ok {
        break
    }
    fmt.Println(value)
}

Quick start (Rust)

cd rust && ./build.sh
./bin/wildling "Year 19##"

use wildling::{Dictionaries, Wildling};

let dicts = Dictionaries::new();
let mut w = Wildling::new(&["Year 19##".to_string()], &dicts);
while let Some(value) = w.next() {
    println!("{value}");
}

Quick start (Kotlin)

cd kotlin && ./build.sh
./bin/wildling "Year 19##"

import wildling.Wildling

val wildling = Wildling.create(listOf("Year 19##"))
var value = wildling.next()
while (value != false) {
    println(value)
    value = wildling.next()
}

Quick start (Ruby)

cd ruby && ./build.sh
./bin/wildling "Year 19##"

require_relative "lib/wildling"

wildling = Wildling.create(["Year 19##"])
value = wildling.next
while value != false
  puts value
  value = wildling.next
end

Quick start (Swift)

cd swift && ./build.sh
./bin/wildling "Year 19##"

let wildling = Wildling(patterns: ["Year 19##"])
while let value = wildling.next() {
    print(value)
}

Quick start (Scala)

cd scala && ./build.sh
./bin/wildling "Year 19##"

val wildling = Wildling(Seq("Year 19##"))
var value = wildling.next()
while (value != false) {
  println(value)
  value = wildling.next()
}

Quick start (Dart)

cd dart && ./build.sh
./bin/wildling "Year 19##"

import 'package:wildling/wildling.dart';

final wildling = Wildling(['Year 19##']);
var value = wildling.next();
while (value != false) {
  print(value);
  value = wildling.next();
}

See language READMEs for patterns, CLI options, and templates. Shared CLI contracts (help text, --check format): docs/cli.md.

Build & test

Language identifiers live in languages.txt. Every */build.sh uses Docker.

./build.sh              # build every language (Docker)
./build.sh powershell   # build one language
./test.sh               # test every language against tests/
./test.sh lua python    # test selected languages
./scripts/build-site.sh # documentation site → _site/

Shared CLI contracts (help text, --check format, out-of-range stderr + exit 1): docs/cli.md. Versioning and publishing: docs/publishing.md.

Contributing

See CONTRIBUTING.md. Security reports: SECURITY.md.

Architecture and stack notes: PLAN.md.

License

MIT — see LICENSE.