Coder Legion - Recent posts tagged gettingstarted

BeingOptimist Social Media Bio Generator

Mon, 27 Apr 2026 21:33:35 +0000

BeingOptimist Social Media Bio Generator is an AI-powered tool that helps creators, professionals, and brands generate engaging, platform-ready bios in seconds. Just add a few details about your niche, tone, and audience to get clear, personalized bio ideas for Instagram, LinkedIn, X, Facebook, and more.

Workshopping my "Anatomy of a Kestra Flow" idea

Tue, 10 Mar 2026 20:53:44 +0000

I pulled together a quick video where I step through 4 different workflows and kind of talk through some ideas I had for more of a polished video. Let me know what you'd like me to focus on or where I should go into more details!

Like these "working out loud videos"? Let me know that too! I'm happy to share more rough drafts in my quest to learn in public.

This was originally posted on dev.to via https://dev.to/missamarakay/workshopping-my-anatomy-of-a-kestra-flow-video-idea-d8h.

Social Media Bio Generator

Wed, 04 Mar 2026 13:47:09 +0000

Generate professional, creative, and platform-specific social media bios in seconds. Use this free Social Media bio generator for Instagram, TikTok, LinkedIn, X, and YouTube.

Free Social Media Content Planner Tool

Tue, 24 Feb 2026 08:04:12 +0000

Create, organize, and schedule 30 days of social media content in just a few minutes with this free social media content planner tool, designed to help creators, freelancers, and small businesses stay consistent without burning hours every week on ideas and planning.

Hello World — For My First Contribution Here, I’d Like to Share a Small Gift: A Free Python Beginner

Fri, 20 Feb 2026 20:06:19 +0000

Hello everyone

As my first contribution to this community, I would like to share a small gift — a free section of my book Python Programming for Beginners. This guide was created specifically for individuals starting from absolute zero, with no prior programming experience at all.

The goal of this book is to provide a clear, structured introduction to Python without unnecessary complexity or overwhelming technical jargon. It focuses on building real understanding through simple explanations and practical examples.

In this sample, you find:
✅ Beginner-friendly explanations of core concepts
✅ Step-by-step, hands-on examples
✅ Exercises designed to reinforce learning
✅ A structured path to help you build real skills

Download the free gift: https://ahmad-khatib.com/en/books/downloads/python-programming-for-beginners-free.epub

Thank you, and I hope you find it valuable. Happy coding!

Guide content in detail:
Introduction
Downloading and Installing the Book’s Requirements
1 – Downloading and Installing Python
2 – Downloading and Installing PyCharm
2.1 – An Exploratory Tour of PyCharm
2.1.i – What is PyCharm?
2.1.ii – The PyCharm Interface
What is the Virtual Environment?
2.2 – Downloading and Installing the Required Packages/Libraries
Chapter 1: An Exploratory Tour in Python
1 – The print() Function
2 – Variables and Values
3 – The Methods: .title(), .lower(), and .upper()
Chapter One Exercise
Chapter 2: Numbers and Strings and Some Basic Operations
1 – Numbers
2 – Use Cases of the Addition Operator (+) with Numbers VS. with Strings
3 – The int() and str() Functions
4 – Number Types in Python And Some Basic Arithmetic Operations
5 – Commands Related to Working with Strings
5.1 – Using Comma (,) Inside the print() Function to Combine Strings and Separate them with a Space
5.2 – The Tab Space (\t), and Moving to a New Line (\n)
5.3 – Defining Strings Using Triple Quotes (""" """)
5.4 – Removing Spaces from String Edges: .strip(), .rstrip(), .lstrip()
5.5 – Removing Text from String Boundaries: .removeprefix(), .removesuffix()
5.6 – Using the Backslash () to Escape Special Characters or Split Long Code Lines
6 – Adding Comments to Code (#)
Chapter Two Exercise
Solution
Chapter 3: Lists and Loops
Do you know about Minecraft?
1 – Introduction to Lists
1.1 – List Elements Ordering, and Element Code
1.2 – Manipulating Lists
1.2.i – Adding Elements to List
1.2.i.a – Appending a New Element at the End of the List Using the .append() Method
1.2.i.b – Adding a New Element at a Specific Order in a List Using the .insert() Method
1.2.ii – Removing Elements from a List
1.2.ii.a – Removing a Specific Element by its Value Using the .remove() Method
1.2.ii.b – Removing a Specific Element by Its Index Using the keyword del
1.2.ii.c – Removing a Specific Element from the List and Returning It Using the .pop() Method
1.3 – Modifying a Specific List Element by Its Index
1.4 – Rearranging List Elements
1.4.i – Rearranging List Elements in Ascending or Descending Order Using the .sort() Method
1.4.ii – Creating a Copy of a List Sorted in Ascending or Descending Order Using the sorted() Function
1.4.iii – Reversing the Order of List Elements Using the .reverse() Method
1.4.iv – Ordering Criteria
2 – The for Loop
3 – The range() and list() Functions
4 – List Dynamics in Python
5 – Statistical Functions: len(), min(), max(), and sum()
Do you know about WhatsApp?
6 – Splitting a List into Parts (Slices)
6.1 – Slicing Syntax
6.2 – Copying Lists Using Slice Syntax, or the .copy() Method
7 – Defining Lists Using Comprehension Syntax
Chapter Three Exercise
Solution
BONUS Jupyter-Ready Interactive Book File
Installing and Running Jupyter
Downloading and Opening the Interactive Book File in Jupyter”

Best Time to Post on Social Media Tool

Tue, 17 Feb 2026 18:49:15 +0000

This free tool converts your audience’s peak activity hours into your own time zone, so you can see the best local times to post on each social platform and maximize engagement without any manual time‑zone math.

My First Flow with Kestra.io

Fri, 06 Feb 2026 13:00:00 +0000

As I'm learning more about Kestra.io, the community, and the possible use cases, I wanted to build a small PoC (proof of concept) that resonated with me and leveraged a fair amount of the platform aspects so I could get some hands on learning beyond the existing tutorials and examples (which are great! Give them a try!).

After talking with a coworker, I loved his daily reminder to log off scheduled on his calendar. This kind of daily ritual is really great for wrapping up your day and leaving work at work. Or at least trying to.

I told him I was going to 100% steal his idea.

Let me walk you through what I'm doing and learning as I go. This won't be a tutorial, but you can see how I learn and explore a new platform, following along with links back to the docs if you want to learn even more.

Requirements of the PoC

I wanted to make sure this PoC covered multiple aspects of the platform, even if it might be a little trivial at times. I wanted to see the dashboards populate with some data, use a few plugins, and start to see the difference between the OSS Edition you can access for free and the paid experience with the Kestra Enterprise Edition.

I needed to interact with the following during my daily or weekly shutdown:

Scheduler/chron - what? You think I would remember to do this daily?
Slack - our main communication tool and where my weekly recap ultimately needed to land, but also where I'll get the reminder
GitHub - no surprise here, where the bugs, feature requests, issues, and PRs live for the source code and docs
Notion - Throw this recap into my "Weekly recaps" so it doesn't get lost on Slack
Google Calendar - Read my calendar and remind me who I talked to today or this week

All of these looked like plugins that should reasonably work well for my PoC. Excellent!

For my first iteration, I won't make this too terribly smart and it will prompt and grab the same info everyday, just for that day. Maybe v2 will do something more comprehensive on Friday when I actually write my weekly recap.

After a quick search through the Blueprints, I didn't find anything specific that I wanted to build off of, so I ended up starting from scratch. I usually recommend building from or extending tutorials and existing examples.

I should also mention I'm building this flow with the flow code editor, directly editing the YAML.

What's a plugin?

Plugins are the essential building blocks for tasks and triggers in your workflow in Kestra. This might be a subtle shift from some platforms where the plugins are extensions or integrations, which they are in Kestra too, but they also include core functionality. You'll probably end up using several plugins in your flow, and many more if you are doing something non-trivial.

See if you can spot the plugins I use in the YAML snippets below. You'll see a mix of 3rd party integrations and core functionality.

Kestra UI

Learning new tools always requires spending a little time mapping your existing knowledge to the UI and terms.

One of the things that I really struggled with early on was the purple, primary action button in the top right corner of the UI changes depending on what screen I'm on. So it could be used to create a flow, execute a flow, create a user (in Kestra Enterprise Edition), etc.

Leave me a comment and let me know how you feel about this UI design choice. Is it intuitive for you? Do you want a more descriptive button name?

Triggers

You probably want to do something when something happens, whether that's a moment in time or based on an event like a form being submitted or new data arriving. You need a trigger for that. For my PoC, I want this to run every weekday around 4pm, when I'm thinking about wrapping up for the day.

triggers:
  - id: daily_shutdown
    type: io.kestra.plugin.core.trigger.Schedule
    #UTC Austin @ 4pm (could add timezone), except weekends
    cron: 0 22 * * 1-5

I like these at the top of the YAML because they show me exactly when this flow happens.

Tasks

Flows require at least one task. You simply cannot save a flow without a task. This makes sense because why would you have a flow that does nothing.

I'll have several tasks in my flow, but I want to make sure I see a reminder or prompt in Slack. That will look something like this with the Slack plugin:

id: send_reminder_message_to_slack
    type: io.kestra.plugin.notifications.slack.SlackIncomingWebhook
    url: "{{ secret('SLACK_WEBHOOK') }}"
    payload: |
      {
        "text": "Time to shutdown"
      }

I'll need to revisit this to add something more interesting to the payload (like info from other tasks), but sending a Slack message is as easy as getting the tokens and secrets configured.

Eventually, it will look like this:

id: send_meetings_to_slack
      type: io.kestra.plugin.notifications.slack.SlackIncomingWebhook
      url: "{{ secret('SLACK_WEBHOOK') }}"
      payload: |
        {
          "text": "Here are the meetings you went to today: {{ outputs.get_calendar_events.events }} "
        }

But we'll talk more about outputs a bit later.

Logging

I ended up doing a lot of logging tasks between the tasks that used plugins, mostly to verify what was coming back in the response and if I wanted to do anything else.

- id: get_cal_list_log
    type: io.kestra.plugin.core.log.Log
    message: "{{ outputs.get_calendar_events }}"

I'm still having some trouble getting the Google Calendar plugin to send more than an empty array back, so for now I'm logging the whole object I get back to see if I get any clues.

Flowable tasks

I threw in a flowable task because depending on how you classify a meeting, I don't have meetings everyday. I do have a blocker for lunch everyday, which is technically a meeting...

- id: if
    type: io.kestra.plugin.core.flow.If
    condition: " {{ outputs.get_calendar_events.events  == [] }} "
    then:
    - id: send_no_meetings_to_slack
      type: io.kestra.plugin.notifications.slack.SlackIncomingWebhook
      url: "{{ secret('SLACK_WEBHOOK') }}"
      payload: |
        {
          "text": "Hooray! No meetings today."
        }
    else:
    - id: send_meetings_to_slack
      type: io.kestra.plugin.notifications.slack.SlackIncomingWebhook
      url: "{{ secret('SLACK_WEBHOOK') }}"
      payload: |
        {
          "text": "Here are the meetings you went to today: {{ outputs.get_calendar_events.events }} "
        }

I really like the human readable way this, well, reads. If, then, else shows me what the condition is and what's going to happen for the two branches.

I know some platforms allow you to define a default path for flows, but I didn't see that here, which I actually really like. Introducing a default path feels confusing when you should rely on the evaluation of the condition.

As I mentioned above this is currently always getting [] back from the Google Calendar plugin, so apparently I never have meetings, but when it works I'll have that taken care of with this flowable task.

Outputs

I added an output that was trivial because I was most likely going to send the summary of the work I did to Slack in the message payload and wasn't sure if there would be any difference if I did or didn't have an output.

outputs:
  - id: sent_bool
    type: BOOLEAN
    value: "true"

In the execution outputs, I wanted to see something I added and where it would show up in the UI. Again, trivial, because in this iteration I don't anticipate this flow making data available for a subsequent flow.

I did use outputs across the various tasks too, so I could use the data from one task in the following task.

Revisions

Don't do what I did as a lazy developer and put my secrets right into my flow. They stay in your revision history. Plain text. Oops.

Secret handling in the Enterprise Edition is too easy to not use, so don't put your secrets plain text in your flow. Keep your secrets secret. Then use an expression like below:

{{ secret('SLACK_WEBHOOK') }}

Revisions become really powerful as you are making changes to your flow, particularly while you are building and testing because sometimes a change doesn't work like you want, and through revisions you can see exactly what changes were made.

Where I'm at

I love that I can export an image of my topology directly in Kestra.

So for now I don't have a "working" increment that I'm happy with. While it is firing every day, I still need to dig into why Google Calendar thinks I have no meetings... when I definitely have meetings. I'm currently playing around with public/private event visibility to see if that changes anything. More on that next week I'm sure when I also add the Notion and GitHub plugins.

Have you built something with Kestra? Link me to your repo in a comment below.

Getting Started with esbuild in Angular

Fri, 09 Jan 2026 18:35:47 +0000

Creating a New Angular Project with the New Build System

Angular’s developer experience took a huge leap forward when it adopted esbuild as the default build engine.

If you remember:

Slow rebuilds
Long ng serve startup times
Heavy Webpack configs

That era is officially over.

This guide shows:

What esbuild means for Angular
How to create a new Angular project using it
What changes for developers
How to customize it safely

What Is esbuild (and Why Angular Switched)?

esbuild is an extremely fast JavaScript bundler written in Go.

Angular adopted esbuild to:

Drastically reduce build times
Improve Hot Module Replacement (HMR)
Simplify the build pipeline
Improve DX for large apps

You do not install esbuild manually
Angular CLI handles it for you

Angular + esbuild: The Big Shift

Modern Angular (v17+) uses:

esbuild for development
Optimized pipelines for production
Webpack only for legacy or advanced edge cases

For most apps:

esbuild is already the default

Step 1️⃣ Create a New Angular Project (esbuild by Default)

npm install -g @angular/cli

ng new my-esbuild-app
cd my-esbuild-app
ng serve

✅ That’s it.
You are already using esbuild.

No flags.
No config.
No setup.

Step 2️⃣ Verify esbuild Is Being Used

Run:

ng build

You’ll notice:

Much faster builds
Smaller output
Cleaner logs

In angular.json, you’ll see:

"builder": "@angular-devkit/build-angular:application"

⬆️ This builder internally uses esbuild

Step 3️⃣ Enable Faster Dev Experience (HMR)

Angular + esbuild supports fast HMR out of the box.

ng serve --hmr

DX Improvement

✔ State preserved
✔ Instant updates
✔ No full page reload

Perfect for:

Forms
Dashboards
Signal-based apps

Step 4️⃣ esbuild + Standalone Angular (Recommended)

Modern Angular works best with:

Standalone components
esbuild
Signals

Example:

bootstrapApplication(AppComponent, {
  providers: [
    provideHttpClient()
  ]
});

No modules.
No ceremony.
Faster builds.

Step 5️⃣ Using Assets, Styles & Environment Files

esbuild handles:

CSS
SCSS
Assets
Environment replacements

angular.json (no custom config needed):

"assets": ["src/assets"],
"styles": ["src/styles.scss"]

Environment switching still works:

import { environment } from '../environments/environment';

Step 6️⃣ TypeScript, Path Aliases & esbuild

esbuild respects tsconfig.json.

Example:

{
  "compilerOptions": {
    "paths": {
      "@core/*": ["src/app/core/*"]
    }
  }
}

✔ Works out of the box
✔ No webpack aliases required

Step 7️⃣ esbuild + Signals = DX Sweet Spot

esbuild pairs extremely well with:

Angular Signals
Zoneless change detection
RxJS interop

Why?

Faster rebuilds
Instant feedback loops
Less mental overhead

This is where modern Angular truly shines.

What You Cannot Do (Yet) with esbuild

Be aware of limitations:

❌ Custom Webpack loaders
❌ Complex build-time plugins
❌ Non-standard bundling hacks

If you need these:

You may still opt into Webpack
But most apps don’t need it anymore

Migrating an Existing Angular App to esbuild

If your app is Angular 16+:

ng update @angular/core @angular/cli

Then update angular.json to use:

"builder": "@angular-devkit/build-angular:application"

That’s usually enough.

Performance Comparison (Real Impact)

Task	Old (Webpack)	New (esbuild)
`ng serve` start	Slow	⚡ Fast
Rebuild	Medium	⚡⚡ Instant
HMR	Unstable	Smooth
Config	Heavy	Minimal

Why This Matters for Developer Experience

esbuild enables:

Faster feedback loops
Better debugging
Happier developers
Scalable teams

This is not a “nice-to-have” change —
it’s a productivity multiplier.

Final Thoughts

Angular didn’t just adopt a faster bundler.
It rethought the entire developer workflow.

With:

esbuild
Standalone APIs
Signals
Better DevTools

Angular is now one of the fastest frameworks to develop with.

TL;DR

New Angular projects use esbuild by default
No manual setup required
Builds are dramatically faster
HMR is smooth and reliable
Best paired with standalone + signals

new application builder – using modern tools esbuild and Vite
ng update @angular/cli --name use-application-builder

10. FSM_API for Non-Coders: A Big Picture Overview (From our Documentation)

Sat, 15 Nov 2025 22:14:52 +0000

We believe the most reliable software logic is logic everyone can understand.

The complex systems that drive modern applications—from character AI in games to business workflows and industrial robotics—are often best articulated not by a developer, but by the subject matter experts. These experts instinctively express domain behavior as an organized set of phases and rules, often visualized as hierarchical Finite State Machines.

This natural structure is the foundation of the Finite State Machine (FSM), and it is why we created this overview. FSMs are not merely a developer’s tool; they are a universal language. This guide is designed to bridge the gap, enabling your domain expertise to translate seamlessly and reliably into the design of robust, predictable, and maintainable software systems.

Without any further ado:

10. FSM_API for Non-Coders: A Big Picture Overview

Have you ever tried to describe a complex process to someone, like making coffee ☕ or building a LEGO castle , and found yourself saying, "First you do this, then if that happens, you do this other thing, otherwise you do something else entirely"? If so, you've already grasped the core idea behind Finite State Machines (FSMs)!

At its heart, FSM_API is a powerful tool designed to make complex software behaviors predictable, organized, and easier to manage, even if you don't write code yourself. It helps turn messy, "if-this-then-that" logic into clear, step-by-step instructions.

What is a Finite State Machine (FSM)? (The Simple Version)

A simple, real-world example of an FSM: a traffic light.

Imagine anything that changes its behavior based on its current situation.

A traffic light is either Red, Yellow, or Green. It can't be Red and Green at the same time. It changes from Green to Yellow only, not directly to Red.
A door is either Closed, Opening, Open, or Closing.
A game character might be Idle, Walking, Running, Jumping, or Attacking.

An FSM is just a way to formally describe these behaviors:

States: These are the specific "situations" or "modes" an entity can be in at any given moment (like "Green" for a traffic light, or "Walking" for a character). An FSM is always in exactly one state at a time.
Transitions: These are the rules that dictate how an entity moves from one state to another (e.g., from "Green" to "Yellow" when a timer runs out, or from "Walking" to "Jumping" when the player presses the jump button).

FSM_API helps developers build and manage these FSMs in a clear and organized way, making sure all the rules are followed and behaviors are predictable.

How FSM_API Helps You (Even if You Don't Code)

While FSM_API is a coding tool, its benefits directly impact anyone involved in designing or understanding the behavior of a system, like game designers, project managers, or QA testers.

1. Clearer Communication

An FSM diagram like this gives the whole team a clear map of how the AI should behave.

Instead of ambiguous descriptions, an FSM provides a visual and logical map of how something behaves. Everyone on the team can look at an FSM diagram and immediately understand the flow.

Example: "The enemy moves from 'Patrolling' to 'Chasing' when it 'sees' the player." This becomes a clear transition rule.

2. Fewer Bugs & More Reliable Behavior

When behaviors are explicitly defined, it's much harder for unexpected "edge cases" or illogical situations to occur (like a character trying to jump while they are already dead). This leads to more stable and reliable software.

Benefit: Less time spent fixing frustrating, unpredictable issues.

3. Easier to Change and Expand

Because the behavior is modular (broken into states and transitions), adding new features or changing existing ones becomes much simpler. You don't have to overhaul the entire system.

Example: Want to add a "Stealth" state to your enemy? You simply add the new state and define how to get into and out of it, without breaking the existing "Patrol" or "Chase" logic.

4. Better Performance

FSM_API is built to be fast. This means your games or applications will run smoother, even when managing many complex characters or systems at once.

Benefit: A more responsive and enjoyable experience for the end-user.

5. Empowers Non-Coders (The "Context" Connection)

The FSM (the brain) contains the logic, while the Context (the body) is the actual object that performs the actions.

When a developer uses FSM_API, they link the FSM to an actual "thing" in your game or application (this "thing" is called the Context).

Example: A game designer might say, "When the character is in the 'Jumping' state, I want them to play the 'Jump_Anim' and add an upward force." The developer then connects the FSM's "Jumping" state to the character's script (their Context) which knows how to play animations and apply force.
Benefit: This clear connection means designers can specify behavior in terms of game actions, and developers can implement it precisely, using the FSM as the bridge.

Who is This For?

Game Designers: Visualize and plan complex character AI, game mechanics, and UI flows with clarity.
Project Managers: Understand the scope and complexity of features related to dynamic behaviors.
QA Testers: Clearly define and test expected behaviors in various scenarios.
Technical Writers: Document system behaviors accurately and concisely.

FSM_API provides a common language and structure that helps bridge the gap between design and implementation, leading to more robust, understandable, and maintainable applications. We are actively working on integrating this into AnyApp, and also preparing it for submission to the Unity Asset Store so developers everywhere can benefit!

Want to Learn More About Development?

If you're interested in learning about the coding side of things from a clear, practical perspective, we highly recommend checking out Tim Corey. He's widely recognized as a fantastic resource for software development, and you can find his insightful content, courses, and community on his platform, DevForge, at iamtimcorey.com.

Resources & Code:

The FSM Package (Unity Asset Store):
https://assetstore.unity.com/packages/slug/332450

NuGet Package (Non-Unity Core):
https://www.nuget.org/packages/TheSingularityWorkshop.FSM_API

GitHub Repository:
https://github.com/TrentBest/FSM_API

Support Our Work:

Patreon Page:
https://www.patreon.com/c/TheSingularityWorkshop

Support Us (PayPal Donation):
https://www.paypal.com/donate/?hosted_button_id=3Z7263LCQMV9J

03. Getting Started with FSM_API in Pure C# (From our Documentation)

Fri, 14 Nov 2025 22:19:58 +0000

Previously we published a deep dive included with our documentation in our FSM_API nuget package for our truly unique feature, runtime recomposition/definition of our FSMs. In this article we are sharing our document on Getting started in pure c#. We showed you the power, now let us show you how easy it is to start using our 45kb API. Embrace the pure digital power!

Without further rambling:

03. Getting Started with FSM_API in Pure C#

Use FSM_API with pure C# classes — completely decoupled from Unity — for backend logic, simulations, AI, networking, or any state-based system.

This guide shows how to use FSM_API in non-Unity environments (console, services, backends, robotics, etc.) with clean, minimal dependencies.

Install FSM_API into your c# project using Nuget Package

Within your preferred IDE find FSM_API within the NuGet Package Manager and click install.

Install FSM_API into your project using .NET CLI:

dotnet add package TheSingularityWorkshop.FSM_API

Integrate the API into your project

Integrating the API with any c# application is foremost establishing the heartbeat or cadence of when your FSMs operate.

Example c#:

FSM_API.Interaction.Update("YourProcessingGroupName");//Updates all FSMs registered to this processing group.

consider the simplest integration possible, a console application as shown below:

Example c#:

using TheSingularityWorkshop.FSM_API;

//Define the application context
SimpleDemoContext appContext = new SimpleDemoContext();

//now we enter a loop which will run indefinitely until the handle becomes invalid.
do
{
    //We make this update call which will then update the app fsm.  The app's
    FSM_API.Interaction.Update("Main");
} while (appContext.IsValid);

To help with this understanding we will describe an example below along with additional samples which are available on our samples repo.

Samples Repo

What This Example Will Demonstrate

We’ll simulate a basic character health lifecycle using FSM_API — all in pure C#. This example is useful for understanding how FSM_API integrates into any standard C# application, offering the same benefits as in Unity.

This example illustrates:

How to define and link FSMs to standard C# classes as their context.
How a game character transitions through health-related states (Healthy, Damaged, Critically Injured, Dead).
How FSM_API makes these transitions declarative, clean, and maintainable.
How to manually control the "ticking" of FSMs without relying on a game engine's built-in loop.
How FSMs can be revived and continue operating even after simulated "death."

Simulation Flow

The player starts in the Healthy state.
Over several ticks, they take damage, triggering transitions to:
- Damaged
- Critically Injured
- Dead
After death, a revive command is issued.
Health is restored.
The FSM automatically transitions back to Healthy.

All output is printed to the console to simulate animation, audio, and event feedback — ideal for unit tests or backend game systems.

✅ Step 1: Define Your Pure C# Context

Create a standard C# class to represent the "thing" your FSM will manage — like a character, connection, pipeline, or subsystem. This class will hold the data and methods that your FSM's states will interact with.

It must implement the IStateContext interface. Recall from the 01. Core Concepts: Your Guide to FSM_API that IStateContext requires Name and IsValid properties.

Example: `GameCharacterContext.cs`

Example c#:

using System;
using TheSingularityWorkshop.FSM_API;

public class GameCharacterContext : IStateContext
{
    private float _currentHealth = 100f;
    private int _currentAmmo = 10;
    private float _moveSpeed = 5f;
    private bool _isActive = true;
    private bool _isReviveCommandIssued = false;

    public float CurrentHealth => _currentHealth;
    public int CurrentAmmo => _currentAmmo;
    public float MoveSpeed => _moveSpeed;

    // IStateContext Properties
    public string Name { get; set; }
    public bool IsValid => _isActive; // FSM_API uses this to know if the context is still relevant

    public GameCharacterContext(string name)
    {
        Name = name;
        Console.WriteLine($"{Name} context created.");
    }

    // Methods that FSM states will call to interact with this context
    public void TakeDamage(float amount)
    {
        _currentHealth -= amount;
        Console.WriteLine($"{Name} took {amount} damage. Health: {CurrentHealth}");
    }

    public void SetActive(bool active)
    {
        _isActive = active;
        Console.WriteLine($"{Name} active status set to {_isActive}.");
    }

    public void RestoreHealth(float amount)
    {
        _currentHealth += amount;
        if (_currentHealth > 100f) _currentHealth = 100f;
        Console.WriteLine($"{Name} health restored to {CurrentHealth}.");
    }

    public void SimulateMovement()
    {
        Console.WriteLine($"{Name} is moving at speed {MoveSpeed}.");
    }

    public void PlaySound(string soundName)
    {
        Console.WriteLine($"{Name} playing sound: {soundName}");
    }

    // Methods for transition conditions
    public void IssueReviveCommand() => _isReviveCommandIssued = true;
    public void ClearReviveCommand() => _isReviveCommandIssued = false;
    public bool IsReviveCommandPending => _isReviveCommandIssued;
}

✅ Step 2: Define and Create the FSM

With your context ready, you can now define your FSM using FSM_API.CreateFiniteStateMachine() and its fluent builder pattern. Then, create an instance of that FSM, linking it to your GameCharacterContext.

Example: `PureCSharpGameLoop.cs`

<img src="Visuals/Character_Health_FSM.png" alt="A flowchart of the Character Health FSM showing states and transitions." height="200" style="display: block;">

A flowchart of the Character Health FSM showing states and transitions.

This class will set up our FSM definition and manage the FSM instance within a simulated game loop.

Example c#:

using System;
using TheSingularityWorkshop.FSM_API;

public class PureCSharpGameLoop
{
    private FSMHandle characterHealthFSM;
    private GameCharacterContext playerCharacter;

    public void SetupGame()
    {
        playerCharacter = new GameCharacterContext("Hero");

        // Define the FSM blueprint if it doesn't already exist.
        // The FSM definition is reusable across multiple instances.
        if (!FSM_API.Exists("CharacterHealthFSM"))
        {
            FSM_API.CreateFiniteStateMachine("CharacterHealthFSM", processRate: 1, processingGroup: "GameLogic")
                .State("Healthy",
                    onEnter: ctx => ((GameCharacterContext)ctx).PlaySound("HappyTune"),
                    onUpdate: ctx => 
                        Console.WriteLine($"{ctx.Name} is Healthy. Health: {((GameCharacterContext)ctx).CurrentHealth}"),
                    onExit: ctx => ((GameCharacterContext)ctx).PlaySound("SadTune"))
                .State("Damaged",
                    onEnter: ctx => ((GameCharacterContext)ctx).PlaySound("OuchSound"),
                    onUpdate: ctx => 
                        Console.WriteLine($"{ctx.Name} is Damaged. Health: {((GameCharacterContext)ctx).CurrentHealth}"))
                .State("CriticallyInjured",
                    onEnter: ctx => ((GameCharacterContext)ctx).PlaySound("WarningAlarm"),
                    onUpdate: ctx => Console.WriteLine($"{ctx.Name} is Critically Injured!"))
                .State("Dead",
                    onEnter: ctx => ((GameCharacterContext)ctx).PlaySound("DeathRattle"),
                    onUpdate: ctx => Console.WriteLine($"{ctx.Name} is Dead."),
                    onExit: ctx => ((GameCharacterContext)ctx).ClearReviveCommand())
                .WithInitialState("Healthy")
                .Transition("Healthy", "Damaged", ctx => 
                    ((GameCharacterContext)ctx).CurrentHealth <= 75 && ((GameCharacterContext)ctx).CurrentHealth > 25)
                .Transition("Damaged", "Healthy", ctx => 
                    ((GameCharacterContext)ctx).CurrentHealth > 75)
                .Transition("Damaged", "CriticallyInjured", ctx => 
                    ((GameCharacterContext)ctx).CurrentHealth <= 25 && ((GameCharacterContext)ctx).CurrentHealth > 0)
                .Transition("CriticallyInjured", "Damaged", ctx => 
                    ((GameCharacterContext)ctx).CurrentHealth > 25 && ((GameCharacterContext)ctx).CurrentHealth <= 75)
                .Transition("CriticallyInjured", "Dead", ctx => 
                    ((GameCharacterContext)ctx).CurrentHealth <= 0)
                .Transition("Dead", "Healthy", ctx => 
                    ((GameCharacterContext)ctx).IsReviveCommandPending && ((GameCharacterContext)ctx).CurrentHealth > 0)
                .BuildDefinition();
        }

        // Create a live FSM instance, associating it with our playerCharacter context.
        characterHealthFSM = FSM_API.CreateInstance("CharacterHealthFSM", playerCharacter);
        Console.WriteLine($"FSM for {playerCharacter.Name} initialized to state: {characterHealthFSM.CurrentState}");
    }

    // Call this method from your main application loop to update the FSMs
    public void UpdateGameLogic() => FSM_API.Update("GameLogic");

    // Helper methods for accessing character and FSM state
    public GameCharacterContext GetPlayerCharacter() => playerCharacter;
    public string GetCharacterFSMState() => characterHealthFSM.CurrentState;
}

✅ Step 3: Manual Update Loop

Since you don’t have an engine's Update() or FixedUpdate() loop, you'll explicitly "tick" the FSMs yourself from your main application loop or a dedicated manager. You'll call FSM_API.Update() for the processing group you defined.

Example: `Program.cs` (Main Application Entry Point)

<img src="Visuals/Simulation_Timeline.png" alt="A timeline of the 20-tick simulation showing key events and state changes." height="200" style="display: block;">

A timeline of the 20-tick simulation showing key events and state changes.

Example c#:

using System;
using System.Threading; // For Thread.Sleep

public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("--- Starting Pure C# FSM Demo ---");

        var game = new PureCSharpGameLoop();
        game.SetupGame();
        var player = game.GetPlayerCharacter();

        for (int i = 0; i < 20; i++) // Simulate 20 game ticks
        {
            Console.WriteLine($"\n--- Tick {i + 1} ---");

            // Simulate events that affect the character's health
            if (i == 2) player.TakeDamage(30);   // Health: 100 -> 70 (Healthy -> Damaged)
            if (i == 5) player.TakeDamage(20);   // Health: 70 -> 50 (Still Damaged)
            if (i == 8) player.TakeDamage(30);   // Health: 50 -> 20 (Damaged -> Critically Injured)
            if (i == 10) player.TakeDamage(20);  // Health: 20 -> 0 (Critically Injured -> Dead)
            if (i == 12) player.IssueReviveCommand(); // Issue revive command
            if (i == 13) player.RestoreHealth(100);    // Restore health, FSM should transition Dead -> Healthy

            // Advance the FSMs in the "GameLogic" processing group
            game.UpdateGameLogic();

            Console.WriteLine($"Current FSM State: {game.GetCharacterFSMState()}");
            Thread.Sleep(500); // Optional: pause for half a second to observe output
        }

        Console.WriteLine("\n--- FSM Demo Finished ---");
    }
}

Running the Example

To run this pure C# FSM example:

Create a Console App Project in your preferred IDE (e.g., Visual Studio, VS Code with C# extension).
Add FSM_API Reference:
- If FSM_API is available on NuGet, add it via the NuGet Package Manager.
- Otherwise, manually add a reference to the TheSingularityWorkshop.FSM_API.dll file.
Add Code Files:
- Create GameCharacterContext.cs and paste the code from Step 1.
- Create PureCSharpGameLoop.cs and paste the code from Step 2.
- Replace the content of Program.cs with the code from Step 3.
Run the App and observe the FSM transitions and console output, which will show your character moving through different health states.

✅ Summary

FSM_API works seamlessly outside of Unity and other game engines, providing a powerful FSM solution for any pure C# application.
You define your application's data models or entities as classes that implement the IStateContext interface.
FSM definition and instantiation logic remain consistent with Unity usage, using FSM_API.CreateFiniteStateMachine() and FSM_API.CreateInstance().
You gain explicit control over when FSMs process their logic by calling FSM_API.Update("YourGroupName") from your application's main loop or scheduler.
This makes FSM_API an ideal choice for server-side logic, complex simulations, AI systems, backend services, or custom game engines where you need robust and decoupled state management.

Support Us

If you find this project useful, you can support its development through PayPal.

Donate via PayPal

Useful Links

NuGet Package: TheSingularityWorkshop.FSM_API
GitHub Repository: TrentBest/FSM_API
License: MIT License
Advanced Integration On Unity Asset Store!
Basic Integration is pending updates on Marketing content.

Brought to you by

The Singularity Workshop – Tools for the curious, the bold, and the systemically inclined.

Because state shouldn’t be a mess.

Coder Legion - Recent posts tagged gettingstarted

BeingOptimist Social Media Bio Generator

Workshopping my "Anatomy of a Kestra Flow" idea

Social Media Bio Generator

Free Social Media Content Planner Tool

Hello World — For My First Contribution Here, I’d Like to Share a Small Gift: A Free Python Beginner

Best Time to Post on Social Media Tool

My First Flow with Kestra.io

Requirements of the PoC

What's a plugin?

Kestra UI

Triggers

Tasks

Logging

Flowable tasks

Outputs

Revisions

Where I'm at

Getting Started with esbuild in Angular

Creating a New Angular Project with the New Build System

What Is esbuild (and Why Angular Switched)?

Angular + esbuild: The Big Shift

Step 1️⃣ Create a New Angular Project (esbuild by Default)

Step 2️⃣ Verify esbuild Is Being Used

Step 3️⃣ Enable Faster Dev Experience (HMR)

DX Improvement

Step 4️⃣ esbuild + Standalone Angular (Recommended)

Step 5️⃣ Using Assets, Styles & Environment Files

Step 6️⃣ TypeScript, Path Aliases & esbuild

Step 7️⃣ esbuild + Signals = DX Sweet Spot

What You Cannot Do (Yet) with esbuild

Migrating an Existing Angular App to esbuild

Performance Comparison (Real Impact)

Why This Matters for Developer Experience

Final Thoughts

TL;DR

10. FSM_API for Non-Coders: A Big Picture Overview (From our Documentation)

10. FSM_API for Non-Coders: A Big Picture Overview

What is a Finite State Machine (FSM)? (The Simple Version)

How FSM_API Helps You (Even if You Don't Code)

1. Clearer Communication

2. Fewer Bugs & More Reliable Behavior

3. Easier to Change and Expand

4. Better Performance

5. Empowers Non-Coders (The "Context" Connection)

Who is This For?

Want to Learn More About Development?

Resources & Code:

03. Getting Started with FSM_API in Pure C# (From our Documentation)

Install FSM_API into your c# project using Nuget Package

Install FSM_API into your project using .NET CLI:

Integrate the API into your project

What This Example Will Demonstrate

Simulation Flow

✅ Step 1: Define Your Pure C# Context

Example: GameCharacterContext.cs

✅ Step 2: Define and Create the FSM

Example: PureCSharpGameLoop.cs

✅ Step 3: Manual Update Loop

Example: Program.cs (Main Application Entry Point)

Running the Example

✅ Summary

Support Us

Useful Links

Brought to you by

Example: `GameCharacterContext.cs`

Example: `PureCSharpGameLoop.cs`

Example: `Program.cs` (Main Application Entry Point)