DEV Community: William Arin

Stochastix: High-Performance Quantitative Backtesting Engine in PHP/Symfony

William Arin — Thu, 19 Jun 2025 15:08:21 +0000

Have you ever wanted to backtest your trading strategies in PHP, instead of Python or MQL5? Well, probably not, as PHP is not the first language that comes to mind for algotrading. However, I have been working on a project that might change that perception.

Stochastix is a high-performance quantitative backtesting engine designed for PHP developers. It allows you to test your trading strategies against historical data, providing insights into their performance, visual analysis, and more. The engine is built with performance in mind, leveraging PHP's ds and bcmath extensions to handle large datasets efficiently, using a custom binary format.

If you've worked with Freqtrade or MQL5, you should feel at home as most concepts are similar. The engine is architectured as a Symfony bundle, which facilitates the engine upgrades and allows you to build your own application on top of it.

Tech stack

The engine is built with the following technologies:

PHP 8.4
Symfony 7.3
Nuxt 3
Mercure for real-time updates
Docker for containerization
SQLite for the message queue

Features overview

bar-by-bar processing
market, limit, stop orders
multi-timeframe strategies
custom indicators
binary formats to speed up data loading
automatic data download from lots of exchanges (ccxt lib)
UI built with Nuxt with real-time updates with Mercure
chart plotting showing indicators and executed trades
number metrics and visual metrics (equity curve, drawdown, etc.)
default docker install using FrankenPHP (one-liner installation)
background jobs with Symfony Messenger

Web interface

Although the framework is usable from the terminal, I've also created a web interface to make it easier to visualize the results of your backtests. The interface is built with Nuxt 3 and provides real-time updates using Mercure. It's an easier way to interact with the engine, especially if you want to get visual analysis with interactive charts.

Here are some screenshots:

And more...

What does a strategy look like?

Here's a simple example of a strategy that uses a moving average crossover to generate buy and sell signals.

Installation

I recommend you to read the official documentation at https://phpquant.github.io/stochastix-docs/ to be sure to not miss anything, but here's how you can install a new project, using this one-liner:

docker run --rm -it --pull=always -e HOST_PWD="$PWD" \
  -v "$PWD":/app -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/phpquant/stochastix-installer your-project-name

I'd be happy to get some feedback, suggestions or contributions. If you want to try it out, you can find the code on GitHub below. Leave a star if you like it!

phpquant / stochastix-core

High-Performance Quantitative Backtesting Engine

Stochastix

Stochastix is a high-performance, event-driven quantitative trading backtesting engine built with PHP and Symfony. It provides a modular and extensible framework for developing, testing, and analyzing algorithmic trading strategies.

Key Features

Event-Driven Architecture: Built for performance and realism.
Advanced Order Types: Supports Market, Limit, and Stop orders with a full pending order book.
Multi-Timeframe Engine: Develop strategies that analyze data across multiple timeframes simultaneously.
Extensible Metrics: A full suite of performance metrics (Sharpe, Sortino, Calmar, etc.) with a dependency-aware calculation engine.
High-Performance Storage: Custom binary file formats for efficient market data storage and retrieval.
User Interface: Modern web interface to download market data, launch backtest and analyze results.
REST API: A complete API for building custom interfaces, including real-time progress updates via Mercure.

Documentation

For the latest official documentation, visit the Stochastix Documentation.

Installation

This project is a Symfony bundle. To install it in your application:

Require the…

View on GitHub

Cook: an alternative to Symfony Flex to execute package-embedded recipes for any PHP project

William Arin — Sun, 19 Feb 2023 15:46:26 +0000

For the devs out there not working with Symfony, Flex is a Composer plugin that allows to automate Symfony plugins configuration with a recipe, which is a list of things to configure.

It works by fetching a separate repository containing the recipe, either hosted by Symfony in symfony/recipes and symfony/recipes-contrib, or self-hosted with some extra steps required. It's good and it works. But it could be better: embedded in repositories. Unfortunately the Symfony team doesn't plan on adding this feature. It's been rejected here, here and here.

While I totally respect their decision, I don't really understand the reasoning. We're left with one option: separate recipe repository. It would be nice if we had all options available, and we're missing the package-embedded one. And so I tried to fill this gap.

Introducing Cook.

Cook is a Composer plugin that executes recipes embedded in packages. It can be used alongside with Flex, or in any other PHP project not limited to Symfony, as long as Composer is installed.

Features:

Add new entries to arrays or export new arrays, filter how you want to output it
Add content to existing files or create them (.env, .gitignore, Makefile, or anything else)
Copy entire directories from your repository to the project
Keep existing data by default or overwrite it with a CLI command
Supports PHP arrays, JSON, YAML, text files
Output post install instructions
Process only required packages in the root project
Uninstall recipe when a package is removed
CLI commands to install or uninstall recipes

Basically it's Flex without Flex.

Here's the repository with full documentation:

williarin / cook

Composer plugin to execute recipes embedded in packages

Cook

Baking recipes for any PHP package.

Cook
- Introduction
  - Features
- Installation
- Documentation
  - Creating a recipe
  - Mergers
    - Text
    - PHP array
    - JSON
    - YAML
    - Docker Compose
  - Placeholders
  - CLI
- License

Introduction

Cook is a Composer plugin that executes recipes embedded in packages, in a similar fashion to Symfony Flex. It can be used alongside with Flex, or in any other PHP project, as long as Composer is installed.

Features

Add new entries to arrays or export new arrays, filter how you want to output it
Add content to existing files or create them (.env, Makefile, or anything else)
Copy entire directories from your repository to the project
Keep existing data by default or overwrite it with a CLI command
Supports PHP arrays, JSON, YAML, text files
Output post install instructions
Process only required packages in the root project
Uninstall recipe when a package is removed
CLI commands to…

View on GitHub

Please give a star if you like it!

SWORD: the merge of Symfony and WordPress

William Arin — Thu, 15 Sep 2022 05:17:17 +0000

It could be a new beginning in the WordPress era. Imagine WordPress being WordPress, but also being Symfony. Not a subset of WordPress and a subset of Symfony. Both WordPress and Symfony at their full potential, at the same time, on the same application.

Sounds like a dream? It's now reality.

Meet Sword. The best of both worlds.

So, what Sword really is and what problems does it solve? If you've heard of Bedrock, it's similar but with Symfony.
Sword is Symfony running WordPress.

It allows you to:

use a centralized composer for WordPress core and plugins as well as other libs
extend a WordPress website well outside its bounds, into the modern framework territory
give WordPress code standardized and modern style and patterns
bring all the good things of Symfony into WordPress, be it dependency injection, translator, Symfony UX, etc...

There's no limit to what you can do.
You want Symfony routes bypassing WordPress? No problem, it's a Symfony app.
You need Symfony UX into your WordPress theme? Sure.
You need a specific page to be 100% Symfony with API calls to WordPress API? Yes you can.

Full installation with Docker takes one command. Zero configuration. No Docker knowledge needed (recommended for further usage though).
Your Sword app should be ready in one or two minutes.

Performance wise, it seems fast enough. Pure Symfony performance is not impacted, the WordPress side is maybe 90ms slower. No big deal given the superpowers you get in exchange.

Here's the link: https://getsword.com

If you like it please give a star on the Github repo and share it!

phpsword / sword-bundle

Modern WordPress development with Symfony

Introduction

Modern WordPress development with Symfony.

Documentation

Visit https://getsword.com/ for official documentation.

Contributions

Feel free to submit issues and pull requests.

License

MIT

View on GitHub

I previously posted on Reddit, it got some attention with interesting comments. Check it out eventually:

Symfony meets WordPress. I call it Sword.

Sep 11 '22 Author: williarin

Few months ago I came here to introduce a library to work with WordPress database from a third party app (WordpressInterop). I use it to work in a Symfony app that connects to some WordPress websites.

And then I had a monolithic dream. While the world is falling apart into microservices, I had a vision of WordPress and Symfony merging…

See Full Post

William ArinFollow

Developing Sword (getsword.com), NumberNine CMS (numberninecms.com) and other things.

Secure your MySQL/MariaDB backups with GFS retention and encryption

William Arin — Fri, 07 Jan 2022 15:35:18 +0000

While there are plenty of existing Docker images to backup MySQL/MariaDB databases with a rotating scheme, I needed GFS retention scheme. GFS as in Grandfather-father-son, with several backup cycles: daily, weekly, monthly, yearly.

So I created this image for my own use at first, then I published it with MIT license.

williarin / secure-mysql-backups

Long-term retention for secure MySQL backups

This Docker image will backup your MySQL/MariaDB databases following the Grandfather-Father-Son (GFS) retention scheme.

Features

GFS backups retention scheme
AES256 encryption/decryption
Single or multiple databases backups
Grouped or individual archives
Parallelized compression

GFS retention scheme

This means that you'll always have:

A backup for every day of the last week (6)
A backup for every week of the last month (4)
A backup for every month of the last year (12)
A backup for every previous year (unlimited)

For a 100MB backup, it will cost you around 2GB for the current year + 100MB for each previous year.

In SuperSafe mode, you'll have:

A backup for every day of the last month (28~31)
A backup for every week of the last year (48)
A backup for every previous year (unlimited)

For a 100MB backup, backups will cost you around 8GB for the current year…

View on GitHub

Features

Swarm-ready

All configuration variables can be sourced from a file. This is ideal when deploying with Docker Swarm, as you can source your passwords from Swarm secrets.

GFS backups with 2 retention schemes

Normal GFS mode

In this mode, you'll have:

A backup for every day of the last week (6)
A backup for every week of the last month (4)
A backup for every month of the last year (12)
A backup for every previous year (unlimited)

SuperSafe mode

In SuperSafe mode, you'll have:

A backup for every day of the last month (28~31)
A backup for every week of the last year (48)
A backup for every previous year (unlimited)

AES256 encryption and decryption

Archives can be encrypted and decrypted with AES-256-CBC algorithm.

Single or multiple databases backups

You can either create an archive with all your databases inside, or one archive per database.

Parallelized compression

If your server has multiple CPUs, compressing the archives will use them all. You can configure the number of CPUs to be used to avoid saturating your server.

Manual backups

You can also trigger a backup manually.

Future proof

This image has been tested with multiple unit and functional tests that cover all the code.

Next steps

Learn more about how to use this image on the Github repo.

What other features would you like to see in this image?

Create dynamic Tailwind CSS color palettes

William Arin — Sat, 21 Aug 2021 14:08:07 +0000

Sure, there are tools out there that will generate for you a color palette for a given color. But will you want to manually generate it again and copy the hex values every time you update the color?

No.

Tailwind CSS gives us the ability to generate dynamic palettes, although it requires a little JavaScript function to make it work.

Start with defining a root color

The trick is to work with HSL values.

Let's say we want to have a palette from the color #0c8a4b and call it primary. The first step is to get the HSL values. To get them, we can use this color converter website https://convertacolor.com/ or any color picker like the one in the browser's DevTools.

In the HEX field, we enter #0c8a4b.

It will give us in return a HSL field containing hsl(150,84%,29.4%).

Now in our CSS file, we define our base color:

:root {
    --color-primary-h: 150;
    --color-primary-s: 84%;
    --color-primary-l: 29.4%;
}

Be careful, the first value H is not a percentage.

Extend Tailwind CSS config

In our tailwind.config.js file, we'll add a small function at the top:

function dynamicHsl(h, s, l) {
    return ({ opacityVariable, opacityValue }) => {
        if (opacityValue !== undefined) {
            return `hsla(${h}, ${s}, ${l}, ${opacityValue})`
        }
        if (opacityVariable !== undefined) {
            return `hsla(${h}, ${s}, ${l}, var(${opacityVariable}, 1))`
        }
        return `hsl(${h}, ${s}, ${l})`
    }
}

This function will convert 3 given HSL values into a CSS property. Thanks to Tailwind CSS 2.0 and above, our generated color palette will also be able to take opacity into account.

And now we extend the theme using this new function:

module.exports = {
    theme: {
        extend: {
            colors: {
                primary: {
                    DEFAULT: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'var(--color-primary-l)'),
                    100: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'calc(var(--color-primary-l) + 30%)'),
                    200: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'calc(var(--color-primary-l) + 24%)'),
                    300: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'calc(var(--color-primary-l) + 18%)'),
                    400: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'calc(var(--color-primary-l) + 12%)'),
                    500: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'calc(var(--color-primary-l) + 6%)'),
                    600: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'var(--color-primary-l)'),
                    700: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'calc(var(--color-primary-l) - 6%)'),
                    800: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'calc(var(--color-primary-l) - 12%)'),
                    900: dynamicHsl('var(--color-primary-h)', 'var(--color-primary-s)', 'calc(var(--color-primary-l) - 18%)'),
                },
            },
        },
    },
};

By varying the L value alone, the palette will keep a monochromatic look, going from light to dark. Exactly what we want.

Enjoy

This will give us these new utility classes to use where we want:

text-primary (same as text-primary-600)
text-primary-100 to text-primary-900

And following the same pattern:

bg-primary
border-primary
ring-primary
etc.

You can also combine these values with opacity, for instance class="border border-primary border-opacity-25".

Go further

This technique works best when the base color is not too clear and not too dark. Try other percentage values than +30% to -18% and experiment with what better fits your needs.

Split your Symfony views into multiple controllers with NumberNine CMS

William Arin — Fri, 13 Aug 2021 16:43:42 +0000

When building a simple page with Symfony, we usually end up having a controller and a view.

Oftentimes, things get complicated and one controller is not a viable solution anymore, therefore we need to split the view like this:

Symfony offers several ways to split your views into multiple controllers. NumberNine CMS offers two more. We'll see which cons and pros each method provides.

using Twig partials with include

{% include 'my_partial.html.twig' with {message: 'hello'} %}

using Twig partials with embed

{% embed 'my_partial.html.twig' %}
    {% block message %}hello{% endblock %}
{% endembed %}

using embedded controllers

{{ render(controller('MyController', {message: 'hello'})) }}

using Twig components

{{ component('my_component', {message: 'hello'}) }}

using NumberNine components

{{ N9_component('MyComponent', {message: 'hello'}) }}

using NumberNine shortcodes

{{ N9_shortcode('[my_shortcode message="hello"]') }}

Pros and cons of each technique

Twig includes and embeds are great and flexible but their data come from above, which makes the root controller bloated. Of course there are workarounds such as Twig extensions or global variables to access a service, but a view shouldn't retrieve data that the controller didn't send to it.

Embedded controllers are a good solution if they're used sporadically, as they make a new Request and will negatively impact performance.

Twig Components is a better approach than embedded controllers, although they have some limitations. Components are non shared services, which means a new instance is created at every call of {{ component('my_component') }}, erasing previously stored data. This means that if your component registers an event listener, it won't work as the instance is created on the fly.

NumberNine components

NumberNine Components solve the problem of Twig Component's separate instances by creating a new set of template parameters everytime the component is called, but the instance itself of the component stays the same.

A NumberNine Component is a shared service, hence event listeners registered will catch events as they should. Parameters injection is done through setters.

Here's a concrete example.

# templates/page/show.html.twig

{{ N9_component('MyComponent', {example: 'string variable'}) }}

// src/Component/MyComponent/MyComponent.php

final class MyComponent implements ComponentInterface
{
    private string $example;

    public function setExample(string $example): void
    {
        $this->example = $example;
    }

    public function getTemplateParameters(): array
    {
        return [
            'example' => $this->example,
        ];
    }
}

// src/Component/MyComponent/template.html.twig

<p>Displaying custom variable: {{ example }}.</p>

Moreover, just like every other view in NumberNine, component templates are overridable. The theme you use probably uses components, and you'll probably want to adapt the design.

Read more about components on the documentation page.

NumberNine shortcodes

While components are developer-oriented, shortcodes are a user-oriented way to inject templates in the view.

Also known as BBcodes, shortcodes and have been widely used in forums and CMS for years. They are represented by a string that the user can input in his editor.

They have a short syntax:

[my_shortcode message="hello"]

Or an extended syntax:

[my_shortcode]hello[/my_shortcode]

Extended syntax allows for nested shortcodes:

[my_shortcode]
    [my_nested_shortcode message="hello"]
[/my_shortcode]

NumberNine handles shortcodes as services. Each shortcode has its own class which acts like a controller.

As an example, we'll analyze this page header:

Now look at how it's rendered behind the scene:

This is not the result of a manual input in an editor, although it can. To know more about how it was rendered, see the last section of this article about the page builder.

Back to our view splitting. To put it simply, this header is composed of 9 controllers and 9 views, with no negative performance impact.

Let's take the my_account_link shortcode and see how it's built, as it's a very basic shortcode. Its purpose is to automatically link to the user-defined "My account" page:

/**
 * @Shortcode(name="my_account_link", label="My Account Link")
 */
final class MyAccountLinkShortcode extends AbstractShortcode
{
    public function configureParameters(OptionsResolver $resolver): void
    {
        $resolver->setDefaults([
            'loggedOutText' => 'Login / Register',
            'loggedInText' => 'My account',
        ]);
    }

    public function processParameters(array $parameters): array
    {
        return [
            'loggedOutText' => $parameters['loggedOutText'],
            'loggedInText' => $parameters['loggedInText'],
        ];
    }
}

While its template looks like this:

<a href="{{ N9_path(PAGE_FOR_MY_ACCOUNT) }}">
    {%- if is_granted('IS_AUTHENTICATED_REMEMBERED') -%}
        {{ loggedInText|trans }}
    {%- else -%}
        {{ loggedOutText|trans }}
    {%- endif -%}
</a>

Now it can be used either by the developer with {{ N9_shortcode('[my_account_link]') }}, or directly by the user in a text editor with [my_account_link].

That's all! Our views can be split in many ways and still keep a high performance. The main controller stays very light, and every partial controllers handle their own responsability. This makes the code highly reusable and easier to use for both developers and users.

Read more about shortcodes on the documentation page.

Shortcodes and the page builder

NumberNine's page builder relies on shortcodes to build the view. Each shortcode can be defined as an editable shortcode, which will appear in the page builder's list of available components to the user.

This will be the topic of an other article. Meanwhile, check out the documentation to see how to build a page builder component with a shortcode.

Symfony on steroids with NumberNine CMS

William Arin for NumberNine CMS ・ Aug 8 '21

#symfony #php #cms

Symfony on steroids with NumberNine CMS

William Arin — Sun, 08 Aug 2021 05:33:17 +0000

Web agencies and freelancers don't need to waste precious time on project setup and configuration anymore. With NumberNine's installer, you'll be able to start working on a Symfony app in seconds.

Copy/paste this installation one-liner in your terminal, given that you have Docker installed:

docker run --rm --pull=always -t -e HOST_PWD=$PWD \
    -v $PWD:/srv/app -v /var/run/docker.sock:/var/run/docker.sock \
    numberninecms/installer myproject

Boom! Done.

One minute later, even without any prior knowledge of Docker, here's what you get:

The latest Symfony version (symfony/web-skeleton)
The latest NumberNine version
The latest PHP, MySQL, Nginx, Redis, Maildev and blackfire versions running as Docker containers
A PHP Docker container with Cachetool, Composer 2, APCu, Xdebug 3, make, and zsh
A self-signed SSL certificate for myproject.localhost and HTTPS access
A ready-to-use website with all CMS features

Simplicity in mind

NumberNine is a CMS which focus on simplicity of use, both for the end-users and the developers. It automates most of the tedious steps of setting up a new Symfony project, while also easing the maintenance by the clients in charge of their content.

For instance:

Have you ever used MakerBundle to create user, registration form, etc.?
Have you ever created some CRUD controllers for your entities?
Have you ever installed VichUploaderBundle or implemented file upload?

If you answered yes to any of these questions, you'll most probably find benefits using NumberNine. All these are core features.

What's more? It's still a Symfony app, which means that you can develop things that won't interfere with the CMS, the Symfony way. NumberNine acts like an additional CMS layer, so you get the best of both worlds.

Some features

You'll find on this page an exhaustive list of features, but the most notable are:

Client-side image resizing with high quality downscaling algorithm
Granular user management with capabilities assigned to roles
WYSIWYG extensible page builder
Shortcodes
Relationships between entities
Menu creation
Easy Twig theming with inheritance (core -> theme -> app)

It's MIT license, totally free to use.

You can star it on Github if you like it.

numberninecms / cms

Core code of NumberNine CMS

The developer documentation is at https://numberninecms.com.

Bonus video trailer

Split your Symfony views into multiple controllers with NumberNine CMS

William Arin for NumberNine CMS ・ Aug 13 '21

#symfony #cms #php