Textus Samples: Launchers and Installation

Created: 2026-06-15 Updated: 2026-07-13

textus-tutorial is a learning set for understanding Textus component development through small samples. Each sample is not just a runbook; it shows how to design, start, and move Component / Service / Operation toward distributable forms.

Before entering the development steps, this article aligns which launcher is responsible for each development stage.

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 the entry points used by developers. If launchers are stale, failures during development walkthroughs become hard to distinguish among component design, packaging, and environment issues.

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 command … . 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 runtime refresh
$ cncf runtime refresh
$ textus runtime refresh
$ 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.

Latest Stable Public Versions

This series assumes the following latest stable versions available from the public channels as of 2026-07-13. SNAPSHOT and local development runtimes are not used.

Launcher Launcher version Runtime version

Launcher	Launcher version	Runtime version
`cozy`	`0.1.6`	`0.2.25`
`cncf`	`0.2.1`	`0.5.0`
`textus`	`0.2.0`	`0.5.0`

cozy

0.1.6

0.2.25

cncf

0.2.1

0.5.0

textus

0.2.0

0.5.0

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.3
$ cd textus-tutorial-0.1.3
$ curl -L -o textus-tutorial-0.1.3.zip \
  https://www.simplemodeling.org/repository/download/textus/tutorial/textus-tutorial/0.1.3/textus-tutorial-0.1.3.zip
$ unzip textus-tutorial-0.1.3.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.

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

References

In Site

📄 Textus Samples 01: Minimal Execution

Glossary

Operation: In UML, an Operation is a Behavioral Feature of a Classifier that specifies the name, type, Parameters, and Constraints for invoking associated Behavior. The Operation specifies an invocation contract, while a Method or another Behavior realizes it.
Textus: Textus is the runtime foundation for operating software realized through SimpleModeling. It provides execution, operational, and integration mechanisms shared by applications.
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.
Cozy: Cozy is the SimpleModeling toolchain that analyzes Models expressed in CML and other DSLs and transforms them into realization artifacts such as programs, configuration, and documentation.
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.
State: In UML, a State models a situation during which an invariant condition holds. The current State of an Object may determine accepted Events and Operations, applicable Constraints, and possible next Transitions.
SimpleModeling: SimpleModeling is a modeling-centered software development methodology and technology system for constructing a Domain Model from Knowledge, formalizing it in CML, realizing it as executable software through Cozy and AI, and running it on Textus.
CML (Cozy Modeling Language): CML (Cozy Modeling Language) is the SimpleModeling formal modeling language for describing the Executable Model portion of an Object Model that connects to program generation and execution.