Textus Samples: Launchers and Installation

Created: 2026-06-15

textus-tutorial is a hands-on learning set for building and running Textus components through small runnable samples. Internally, the CNCF (Cloud Native Component Framework) engine provides the Component / Service / Operation execution model.

This article explains the functions and installation steps for the launchers required to run textus-tutorial .

What You Learn

  • The relationship between Textus, Cozy Textus, and the CNCF engine

  • The role split among the cozy , cncf , and textus launchers

  • Installation and update via Coursier channels

  • Runtime catalog and runtime current checks

  • Obtaining textus-tutorial and running the full smoke check

Purpose / Why This Sample Matters

This article comes before the samples to align product names, the internal engine name, and the roles of the three launchers. If launchers are stale, failures in any sample become hard to distinguish from environment problems.

The goal is to understand what each launcher starts and what runtime current is checking.

Concept Focus

  • Textus and Cozy Textus are product names. CNCF is the internal engine that runs components.

  • The Coursier channel is the launcher entry point, while the runtime catalog records which runtime version each launcher selects.

  • The public archive name is textus-tutorial , while sample build artifacts are named textus-samples-* .

Launcher Roles

SimpleModeling separates launchers by purpose.

  • cozy : The launcher component developers use for SmartDox, CML generation, build, and publish operations.

  • cncf : The launcher component developers use to start, inspect, and debug components on the CNCF engine.

  • textus : The launcher component users and operators use to deploy and run packaged Textus components and applications.

Because textus-tutorial is a development tutorial, the articles mostly use cncf dev …​ . They use cozy when generating from CML, and textus in the user/operator context for packaged components.

Install

Use Coursier to install each launcher.

$ cs install --force cozy \
  --channel https://www.simplemodeling.org/repository/cozy/coursier-channel.json
$ cs install --force cncf \
  --channel https://www.simplemodeling.org/repository/textus/coursier-channel.json
$ cs install --force textus \
  --channel https://www.simplemodeling.org/repository/textus/coursier-channel.json

After installation, check the selected launcher and runtime versions.

$ cozy launcher version
$ cozy runtime current
$ cncf launcher version
$ cncf runtime current
$ textus launcher version
$ textus runtime current

Runtime catalogs are cached locally. When the local catalog differs from the published recommended runtime, the launcher reports how to refresh or update it.

Command Walkthrough

cs install --force …​ --channel …​ updates the launcher executable. It does not directly replace the runtime; the launcher selects a runtime from its catalog and repositories.

launcher version reports the launcher itself, while runtime current reports the runtime version it sees as recommended. Checking both reveals drift between entry point and execution body.

Reading the Output

If cozy runtime current or similar commands report an older version than expected, refresh the catalog or reinstall before running samples.

Downloaded-package smoke success means the samples work from published artifacts, not from local-checkout-specific settings.

Download Textus Samples

This series assumes that you use the textus-tutorial package downloaded from SimpleModeling.org.

$ mkdir textus-tutorial-0.1.1
$ cd textus-tutorial-0.1.1
$ curl -L -o textus-tutorial-0.1.1.zip \
  https://www.simplemodeling.org/repository/download/textus/tutorial/textus-tutorial/0.1.1/textus-tutorial-0.1.1.zip
$ unzip textus-tutorial-0.1.1.zip

Extract the archive into an empty directory; it places samples/ , scripts/ , versions/ , and related files there. Reader-facing commands do not depend on development checkout paths.

Smoke Check

The basic behavior of all runnable samples can be checked with the following command.

$ bash scripts/run-all-samples.sh

When successful, each sample is marked as PASS , and the final log directory is printed.

PASS 01-minimal
...
PASS 13.a-observability-stack-lab
LOGDIR target/all-sample-validation-...

CNCF Engine Meaning

Launchers are the entry points for running Components, Subsystems, and Operations without manually managing runtime classpaths or artifact selection.

This separation lets the sample articles focus on what is being executed.

Common Pitfalls

  • If the channel is omitted, an installed launcher may be used without consulting the new public channel.

  • Runtime catalog caches are intentionally not auto-refreshed, so when drift appears, read the warning and refresh instructions.

Next

The next article 📄 Textus Samples 01.d:Component Script uses the minimal 01-minimal sample to examine the basic Component / Service / Operation shape.

References

Glossary

Cloud Native Component Framework (CNCF)

Cloud Native Component Framework (CNCF) is a framework for executing cloud application components using a single, consistent execution model. Centered on the structure of Component, Service, and Operation, it enables the same Operation to be reused across different execution forms such as command, server (REST / OpenAPI), client, and script. By centralizing quality attributes required for cloud applications—such as logging, error handling, configuration, and deployment—within the framework, components can focus on implementing domain logic. CNCF is designed as an execution foundation for literate model-driven development and AI-assisted development, separating what is executed from how it is invoked.

Component

A software construct that encapsulates well-defined responsibilities, contracts, and dependencies as a reusable and replaceable unit. In the logical model, it serves as an abstract structural unit; in the physical model, it corresponds to an implementation or deployment unit.

CML (Cozy Modeling Language)

CML is a literate modeling language for describing Cozy models. It is designed as a domain-specific language (DSL) that forms the core of analysis modeling in SimpleModeling. CML allows model elements and their relationships to be described in a narrative style close to natural language, ensuring strong compatibility with AI support and automated generation. Literate models written in CML function as intermediate representations that can be transformed into design models, program code, or technical documentation.