Category: Development

Software development updates and insights

  • Flutter vs React Native in 2026: Architecture, Performance, and the Right Choice

    Flutter and React Native are the two leading cross-platform mobile frameworks, backed by Google and Meta respectively. Both promise “write once, run anywhere,” but take fundamentally different architectural approaches.

    Architecture

    Flutter renders every pixel itself using the Impeller engine — no native UI components. Pixel-perfect consistency across platforms, but no automatic platform-native look and feel. React Native bridges to native components (<View>UIView/android.view.View). Native look by default. The New Architecture (Fabric + TurboModules + JSI) replaces the old async bridge with synchronous communication.

    Language & Developer Experience

    // Flutter (Dart)
    import 'package:flutter/material.dart';
    void main() => runApp(const MyApp());
    class MyApp extends StatelessWidget {
        const MyApp({super.key});
        @override
        Widget build(BuildContext context) => MaterialApp(
            home: Scaffold(
                appBar: AppBar(title: const Text('Flutter')),
                body: const Center(child: Text('Hello Flutter')),
            ),
        );
    }
    // React Native (TypeScript)
    import React from 'react';
    import { View, Text, StyleSheet, SafeAreaView } from 'react-native';
    
    export default function App() {
        return (
            <SafeAreaView style={styles.container}>
                <Text style={styles.text}>Hello React Native</Text>
            </SafeAreaView>
        );
    }
    const styles = StyleSheet.create({
        container: { flex: 1, justifyContent: 'center', alignItems: 'center' },
        text: { fontSize: 24, fontWeight: 'bold' },
    });

    Flutter/Dart: Null safety, pattern matching, sealed classes. Moderate learning curve. “Everything is a widget.” React Native/TypeScript: The React model (props, hooks, context) transfers directly from web. Access to the massive npm ecosystem.

    Performance & Ecosystem

    Flutter outperforms in animation-heavy, GPU-intensive, and custom-rendering scenarios. React Native’s New Architecture has closed the gap for typical CRUD apps. Flutter: 40K+ pub.dev packages, targets web/desktop too. Used by Google Pay, BMW, Alibaba. React Native: npm ecosystem, Expo managed workflow. Used by Meta, Microsoft, Shopify, Discord.

    When to Choose

    Flutter: Custom UI-heavy apps, pixel-perfect consistency, web+desktop from same codebase, teams without JS expertise. React Native: Strong JS/React teams, sharing logic with React web app, deep native module integration, platform-convention UIs. Both are production-ready — the decision is team skills + project requirements.

    Further reading: Flutter Docs | React Native Docs

  • Objectionable Words Plugin Test

    Objectionable Filter for comments which replaces keyword with “******”

  • Noter: Building a Modern WPF Note Editor

    Noter is a modern WPF note editor I’ve been building with a focus on productivity, reliability, and developer-friendly architecture. It combines rich text editing with smart features like wiki-style linking, automatic crash recovery, and performance optimizations for large documents.

    // CORE_FEATURES

    The editor includes a comprehensive feature set designed for developers and power users who need more than basic note-taking.

    Rich Text Editing: Full formatting support including styling, lists, colors, and highlights. The editor handles complex formatting while maintaining document integrity.

    File Encoding Awareness: Automatic detection and conversion of file encodings and line endings. Essential for working with files from different systems and editors.

    Crash Recovery: Autosave with draft and last-session restoration. Never lose work again – the app recovers gracefully from unexpected shutdowns.

    Wiki-Style Links: Support for [[Links]] syntax with automatic backlink discovery. Build a personal knowledge base with interconnected notes.

    // DESIGN_PRINCIPLES

    The architecture follows several key principles that make the codebase maintainable and the application reliable:

    Separation of Concerns: Each user-facing feature cluster has its own module, making the code easier to understand and modify.

    Safe Logging: A LogSafe helper wraps all higher-risk UI operations, ensuring that errors are captured and handled gracefully without crashing the application.

    Lazy Evaluation: Timers and caches for statistics and link parsing use lazy initialization, avoiding unnecessary work on large documents until the data is actually needed.

    Isolated Settings: Editor preferences like zoom level, whitespace visibility, encoding, and line endings are persisted in small helper methods, keeping the settings logic contained and testable.

    // ADDITIONAL_FEATURES

    Beyond the core editing capabilities, Noter includes productivity features that speed up common workflows: quick insert for dates, times, images, files, and audio attachment placeholders; export to PDF and printing; find and replace with highlight-all functionality; inline statistics showing word and character counts with smart throttling for large documents; and a recent files list with pinning support.

    // Technology: C# | WPF | .NET 8 | MVVM Architecture

  • ChimeraCast: Professional Multistreaming Studio

    ChimeraCast is a Windows desktop application for professional multistreaming that I’ve been developing. It combines a modern WPF studio interface with a local ASP.NET Core backend and a Docker-based streaming stack for maximum flexibility and performance.

    // ARCHITECTURE_OVERVIEW

    The application uses a multi-layer architecture designed for reliability and extensibility.

    Studio Interface (WPF/MVVM): The main interface includes scenes and sources management, an audio mixer, and status indicators. Built using the MVVM pattern for clean separation of concerns and testability.

    Encoder Pipeline: FFmpeg-based streaming and recording with NVENC hardware acceleration when available. The pipeline handles encoding, multiplexing, and output to multiple destinations simultaneously.

    Display Capture: Windows Graphics Capture (WGC) for display and window previews with automatic GDI fallback for compatibility. The UI clearly indicates which capture method is active.

    Local Backend: ASP.NET Core service handling channels, stream keys, diagnostics, and real-time updates via SignalR. This keeps the streaming configuration separate from the UI logic.

    // DOCKER_INFRASTRUCTURE

    The streaming infrastructure runs in Docker containers for easy deployment and isolation.

    nginx-rtmp: Core RTMP server with HLS output for web playback. Handles ingest from the studio application and distribution to CDNs or direct viewers.

    Optional stunnel: RTMPS support for secure streaming to platforms that require it. Configured as an optional profile for when SSL encryption is needed.

    SRS (Simple Realtime Server): SRT and WHIP protocol support for low-latency streaming and WebRTC integration. Enables professional broadcast workflows.

    // TARGET_PLATFORM

    The application targets .NET 8 and Windows 10/11, taking advantage of modern Windows APIs while maintaining broad compatibility. The WPF interface provides native Windows look and feel with smooth GPU-accelerated rendering.

    // Technology: C# | WPF | ASP.NET Core | Docker | FFmpeg | SignalR

  • MACH-Inspired User Signup System with React & Laravel

    This demonstration project showcases a modern signup process for a private social media platform. It’s designed for companies that want algorithm-free, ad-free internal communication with a polished user experience and robust role-based access control.

    // MARKETING_PAGES

    The public-facing pages combine modern design with interactive elements.

    Landing Page: Full marketing homepage featuring an animated interactive background with particle effects that respond to cursor movement. The design adapts seamlessly between dark and light modes.

    Pricing Page: Three pricing tiers plus enterprise solutions, presented in a clean, scannable format. Fully responsive across all device sizes.

    // USER_MANAGEMENT

    The signup flow handles various user types with appropriate verification steps.

    Multi-Step Verification: Email verification with a progressive disclosure signup flow. Users provide information in logical stages rather than facing a wall of form fields.

    Role Differentiation: Separate registration paths for team leaders and team members, with appropriate permissions set from account creation.

    Security: Credit card information stores only the last 4 digits. Full client and server-side validation ensures data integrity.

    // ROLE_BASED_ACCESS

    Three distinct permission levels control what users can see and do.

    Super Admin: Full system access including user management dashboard with statistics, status breakdowns, role distribution charts, and registration activity tracking. Can manage all users except other super admins.

    Team Leader: Can invite up to 500 team members via email, manage invitations (resend, cancel), and perform full CRUD operations on their team roster.

    Team Member: View-only access to their team roster. Clean, focused interface without administrative distractions.

    // INTERACTIVE_FEATURES

    The application includes several polish features that improve the user experience: a 5-step interactive onboarding tour, team chat modal (demo interface), consistent user avatars with deterministic colors based on user ID, profile customization with avatar uploads, and light/dark theme toggle throughout.

    // Technology: React | TypeScript | PHP 8.3 | Laravel 11 | MACH Architecture