RSC-Informatik

If you trade the NY open, you know the problem: the work that decides the day has to be done before the day starts. This does that work — an analyst that never sleeps. Three times a day it reads the Nasdaq futures tape and writes the briefing that gives the trader a technical and financial analysis for the coming trading session: a table of the important upcoming events, several scenarios with the probability of each, and charts marking the support and resistance levels as potential long and short entries.

Live AI analysis on top of a purpose-built data feed: exact levels, session profiles and a statistics engine built from every session it has ever seen. It doesn't guess — it reasons over measured base rates, fenced in by hard guards so it never wanders past what the data actually supports.

The loop is what makes it interesting. The pre-open run commits to a plan. After the NY Close, the same system grades that plan against what really happened and folds the result back into the statistics. Every session the statistics get better and the read gets a little sharper. Nobody touches it.

• The three daily runs:
  • Before the NY Open — the plan: scenarios, levels, triggers, invalidation
  • After the NY Close — grades the plan and drives the statistics forward
  • Asia / Europe Outlook — overnight positioning while New York sleeps
• Under the hood: proprietary level engine, own market-statistics repository, strict lookahead and risk guards
• Sample reports: Two reports for the same New York RTH session (07/14/2026).
  • "Before the NY Open" — 9:15am ET (PDF)
  • "After the NY Close" — 4:15pm ET (PDF)

  Not financial advice. These reports are a personal note the author writes to himself — automated, AI-generated, and possibly wrong; any figures or grades are hypothetical and after-the-fact. If you are reading one you hold it incidentally; treat every word as fictional and for entertainment only, act at your own risk, and the author accepts no liability. See the full disclaimer in each PDF.

• Languages: Python, matplotlib, Live AI Prompt (Claude) — running autonomously, unattended
• Status: In production, private

This analysis engine is not tied to the Nasdaq — it can be pointed at another instrument, another session, another desk. It is also a working example of an integrated, self-running application with an LLM at its core — autonomous AI software that does real work unattended, day after day.

Swing trading analysis. This is used to catch higher-timeframe moves of a financial instrument. Whether used for Crypto or traditional instruments, the read is the same: positions are held for weeks, not minutes. That means you do not sit in front of the chart: you get one read, you place your levels, and you let the trade work. Fewer decisions, bigger moves.

The read starts as pure technical analysis: monthly, weekly and daily structure, support and resistance, cross-timeframe confluence zones, moving averages, momentum, volume and TPO profiles. No news, no narrative — price, structure, levels. The AI writes the top-down read and a concrete trade plan straight from those facts.

Then it gets challenged. A second, deliberately hard-nosed desk goes looking for what the levels cannot see — the macro backdrop, what the token is really tracking right now, where a clean technical picture is about to be run over by something outside the chart — and attacks the read on its own numbers. The two are then reconciled into one sober call: the lean, the level that matters most, and the single condition that would flip it.

Underneath it all sit the statistics: dataset extended on every run, and ran against a backtesting grid whenever parameters are added, removed, or retuned. A read may only lean on a rule that has been measured.

• How it reads:
  • Technician — top-down structure, levels, confluence, momentum
  • Challenger — cross-asset and macro pressure-test of that read
  • Reconciliation — one call: the lean, the level, the invalidation
• Weekly statistics, ad-hoc backtesting to tune the parametrization
• Any major token — the plan is drawn on the chart, entries, targets, invalidation
• Languages: Python, matplotlib, Live AI Prompt (Claude) — on demand, one command per symbol
• Status: In production, private

Not financial advice. These reads are a personal note the author writes to himself — automated, AI-generated, and possibly wrong; technical only, no guarantee of anything. Treat every word as fictional and for entertainment only, act at your own risk, and the author accepts no liability.

A TradingView Pine Script (v6) indicator that plots timezone-correct session VWAPs (New York, London, Asia) plus a continuous 24h/daily VWAP, with optional standard-deviation bands. Built for intraday futures traders who watch the chart from a timezone that differs from the exchange — sessions compute in explicit market timezones, so they plot correctly no matter where the chart is viewed from, and daylight saving is handled automatically.

This is a modified derivative of "Koalafied VWAP Session/Day" by TJ_667, released under MPL-2.0. Source and documentation on GitHub.

How to use it: Open TradingView, go to Indicators and search for "RTH Session VWAP" — add it to your chart in one click. The script page on TradingView is here. Or grab the Pine code straight from GitHub (copy-paste or git clone), drop it into TradingView's Pine Editor, and add it to your chart yourself.

• Language: Pine Script v6 (TradingView)
• What was rebuilt:
  • Timezone-correct sessions via explicit market TZ (America/New_York, Europe/London, Asia/Tokyo)
  • NY session defaults to RTH cash hours (09:30–16:00 ET), anchoring VWAP to the 09:30 open
  • Migrated to Pine v6 — explicit boolean casts for `time()` results, since implicit casting was removed
  • Continuous 24h VWAP anchored to the exchange trading day, independent of sessions
  • Per-session toggles, presets, clean legend (helpers hidden from status line)
• Status: Open source on GitHub, MPL-2.0

A language learning app that lets you pick up any language while doing other things. It intermixes theory and practice on background audio — you first hear explanations in English about grammar concepts, followed by examples so you actually understand what is happening. All the while, you still get to use study set cards in a traditional flipping manner.

The app uses three AI providers (ChatGPT, Claude, Gemini) in parallel to enrich word sets with translations, example sentences, and grammar context. Vocabulary can be imported through files, paste, or public Quizlet URLs.

• Languages: Dart, Flutter
• Features:
  • Background audio playback with TTS for hands-free study sessions
  • AI-powered word enrichment using ChatGPT, Claude, and Gemini simultaneously
  • Flashcard study mode with accuracy tracking and spaced repetition
  • Import word sets from files, clipboard, or Quizlet
  • Supports any language pair — from Tagalog to Korean to Romansh
  • Adjustable playback speed and voice selection
  • Vocal set playback for background listening practice
  • Built with Riverpod for reactive state management
  • Debug overlays for system metrics and audio state monitoring
• Status: In development, targeting iOS and Android

The app follows a philosophy of making language learning fit into a busy schedule — you can study while commuting, cooking, or exercising by letting the audio run in the background. The triple-AI enrichment ensures high-quality translations and context across all supported languages.

The company "Gemma design" hand-crafts beautiful furniture with integrated lights. The "Gemma App" connects and controls those lights over the Wi-Fi.
Best to have a look at the Website of Gemma design and maybe buy your own piece.

Check out the App on the Apple App Store! While you won't get to see the full range of the app without a corresponding lamp, you will still see a lot of the functionality, especially the settings and the HTTP Wifi Lookup on the "Connect Device" Screen.

• Languages: Dart, Flutter, C/C++ (Arduino)
• Features, available for fast future reuse in other Apps:
  • Scans for devices on the local Wi-Fi HTTP
  • Device state and datastreams handled "Reactive-ly" (Rx)
  • Stores preferences on local device
  • Dynamic Settings by configuration
  • All dialogs wrapped in abstracted, (still) closed library
  • Multilingual
  • Communication with Arduino Firmware over HTTP/JSON protocol
  • Location permission handling on iOS and Android
  • Integrated WebViews and external Links
  • Haptic Feedback
  • Sentry.io integration for Crash Report Analysis
• Status: Published on the Apple App Store

Note: The Android App is ready but is not yet published for download yet. Soon to come after the last Gradle Build issues are fixed…

A powerful, flexible logging library for Dart and Flutter applications with progressive complexity - from one-line setup to enterprise-grade configurations. Logs can be sent to console, file, JSON HTTP endpoints, email, MySQL databases, or any custom appender extension you create.

Check it out on pub.dev or explore the source code on GitHub.

• Languages: Dart, with platform-specific optimizations
• Core Features:
  • Zero configuration quick start - literally one line of code
  • Automatic device/session tracking with anonymous IDs
  • Progressive complexity from simple to enterprise
  • Performance optimized with early exits and lazy evaluation
  • Built-in file rotation and batching
  • MDC (Mapped Diagnostic Context) for request tracking
  • Fail-fast design with clear error messages
  • Minimal dependencies (only crypto in core)
• Extension Packages:
  • any_logger_json_http: Send logs to REST APIs, Logstash, centralized services
  • any_logger_email: Email alerts with SMTP, batching, HTML formatting
  • any_logger_mysql: Persistent storage with query API and rotation
• Status: Published on pub.dev with 150/150 pub points

The library follows a philosophy of progressive complexity - beginners can start logging with literally one line of code, while enterprise users can configure multiple appenders, custom formats, and sophisticated routing rules. The extension architecture keeps the core lightweight while allowing unlimited expansion through additional packages.

A Flutter plugin to resolve the SSID of the connected WiFi network. It gets the Wi-Fi name of the connected network.
The native code handles the interaction with different permission layers, especially the "Location Services" that have to be granted by the user. This interaction takes away the focus of the App and that requires handling the "re-entry event" with proper thread handling.

• Languages: Swift, Kotlin, Dart
• Features:
  • Very easy integration into client code
  • Mixin support with single method override
  • The code base for this package is fully open-sourced and can be found on github.com
• Status: Published on pub.dev

Flutter is a Google framework that let's developers implement mobile Apps for Android and iOS with a single codebase. However when it comes to more low-level tasks, that involve the specifics of the underlying operating system, you still need to implement these solutions in native Swift (iOS) or/and Kotlin (Android).
Flutter plugins usually combine such efforts by providing implementations for both, iOS and Android operating systems and offering a unified access morphology through a single API.