One ecosystem,many movingparts

// build.sbt
libraryDependencies += "org.galaxio" %% "gatling-kafka-plugin" % "<version>" % Test

import org.galaxio.gatling.kafka.Predef._
import io.gatling.core.Predef._

val kafkaConf = kafka
  .properties(Map("bootstrap.servers" -> "localhost:9092"))

val scn = scenario("Kafka Producer")
  .exec(
    kafka("send message")
      .topic("test-topic")
      .send[String, String]("key", """{"msg": "hello"}""")
  )

setUp(scn.inject(atOnceUsers(1))).protocols(kafkaConf)

// build.sbt — plugin + your JDBC driver
libraryDependencies ++= Seq(
  "org.galaxio" %% "gatling-jdbc-plugin" % "<version>" % Test,
  "org.postgresql" % "postgresql" % "42.7.11" % Test,
)

import org.galaxio.gatling.jdbc.Predef._

val dbConf = DB
  .url("jdbc:postgresql://localhost:5432/test")
  .username("test").password("test")
  .maximumPoolSize(10)

scenario("JDBC Query")
  .exec(
    jdbc("find user")
      .queryP("SELECT * FROM users WHERE id = {id}")
      .params("id" -> "#{userId}")
      .check(simpleCheck(_.nonEmpty))
  )

// build.sbt
libraryDependencies += "org.galaxio" %% "gatling-amqp-plugin" % "<version>" % Test

import org.galaxio.gatling.amqp.Predef._

val amqpConf = amqp
  .connectionFactory(
    rabbitmq.host("localhost").port(5672)
      .username("guest").password("guest").vhost("/")
  )
  .usePersistentDeliveryMode
  .matchByMessageId

scenario("AMQP Publish")
  .exec(
    amqp("publish").publish
      .queueExchange("test-queue")
      .textMessage("""{"msg": "hello"}""")
      .contentType("application/json")
  )

// build.sbt
libraryDependencies += "org.galaxio" %% "gatling-picatinny" % "VERSION" % Test

import org.galaxio.gatling.config.SimulationConfig._
import org.galaxio.gatling.feeders.faker.Predef._

// shared config from simulation.conf, overridable with -D
val httpProtocol = http.baseUrl(baseUrl)

val users = GeneratedFeeder(
  "email" -> Faker.internet.email(),
  "phone" -> Faker.phone.mobile(Country.RU, PhoneFormatMode.E164),
)

rampUsersPerSec(0).to(intensity).during(rampDuration)

# Claude Code
$ claude plugin marketplace add galax-io/ai-plugins

# Codex
$ codex plugin marketplace add galax-io/ai-plugins

# then install the plugin by name
$ claude plugin install \
    galaxio-gatling-pro@galaxio-performance-kit

# Cursor: Dashboard -> Plugins -> Add Marketplace
#         -> Import from Repo

# install (macOS / Linux)
$ curl -fsSL https://raw.githubusercontent.com/galax-io/\
    galaxio-cli/main/scripts/install.sh | sh

# discover and scaffold
$ galaxio template list
$ galaxio template init gatling/scala-sbt \
    --set Name=orders-api \
    --set NameWord=ordersApi \
    -d ./perf-tests

# generate a simulation from an OpenAPI spec
$ galaxio generate swagger --from ./petstore.yaml --init

# scaffold, then enable optional plugin modules
$ galaxio template init gatling/scala-sbt \
    --set Name=my-service \
    --set NameWord=myservice \
    --set KafkaPluginEnabled=true \
    --set JdbcPluginEnabled=true \
    -d ./perf-tests

# compile the rendered project
$ cd perf-tests && sbt -batch Gatling/compile

# the default registry needs no setup, but you can inspect it
$ galaxio template configure --show
$ galaxio doctor

# point at your own registry
$ galaxio template configure \
    --registry github:my-org/my-registry

# or a local checkout, for one command only
$ galaxio template init mypack/mytemplate \
    --registry local:/path/to/registry

# discover
$ specify preset search perf
$ specify extension search perf

# install
$ specify init --preset perf
$ specify extension add <id>

# run the gated pipeline
$ specify workflow run

# install Copier once, isolated
$ uv tool install copier    # or: pipx install copier

# scaffold a new project (--trust runs post-gen tasks)
$ copier copy --trust \
    gh:galax-io/spec-kit-galaxio-bootstrap \
    ~/code/my-new-project

# later, pull template/process updates in
$ cd ~/code/my-new-project && copier update --trust

# examples/one-request-is-fast.yaml — the smallest document
apiVersion: opennfr.io/v1
kind: RequirementSet
metadata:
  name: checkout-perf

spec:
  requirements:
    - name: checkout
      selector:
        loadtest.request.name: POST /checkout
      criteria:
        - metric: loadtest.request.duration
          aggregation: p95
          op: lte
          threshold: 500
          unit: ms

# the schema, the corpus, the links and the language
$ bash scripts/verify.sh

// project/plugins.sbt
addSbtPlugin("org.galaxio" % "sbt-schema-registry-plugin" % "<version>")

// build.sbt — point at your registry
schemaRegistryUrl := "http://localhost:8081"

// download the schemas
$ sbt schemaRegistryDownload

# the galaxio CLI is also published as an image
$ docker pull galaxioteam/galaxio:latest

$ docker run --rm \
    -v "$PWD":/work -w /work \
    galaxioteam/galaxio template list

# nothing is implemented yet — this is what is being built
$ go get github.com/galax-io/parsec

# the packages, once they exist
    model/    canonical result types shared by every source
    gatling/  text and binary codecs, version gate, discovery
    stats/    counts, timings, percentiles, per-interval series

# progress is public: small milestones, each ending in a tag
$ gh release list --repo galax-io/parsec