mwn

What is running, what was tried, what is paused.

Eight experiments opened in section: the surface when there is one, an excerpt of the real code, the repository's modules, the services it calls. Every status is the real one.

The G2 family

G2 reads "Go to". Four video tools on the same Telegram base, from writing a script to publishing, and a cousin that listens to a blockchain.

  1. LAB/012025-2026Active

    G2tiktokWork, the video factory

    A script sent on Telegram comes back as an edited, voiced, word-by-word subtitled vertical video, ready to publish.

    L0 · Surface
    G2tiktokWork landing page: “Your worst work stories. In millions of views.”, with access to the Telegram bot.
    Frame from a video produced by G2tiktokWork: vertical format, word-level karaoke subtitles over background footage.
    L1 · Codemodules/transcriber.py
    heard = [_normalize(w["word"]) for w in words]
    target = [_normalize(t) for t in ref_tokens]
    matcher = difflib.SequenceMatcher(a=heard, b=target, autojunk=False)
    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
        count = j2 - j1
        if count == 0:
            continue  # Whisper a entendu des mots absents du script.
        if tag == "equal":
            for k in range(count):
                aligned.append(
                    {
                        "word": ref_tokens[j1 + k],
                        "start": words[i1 + k]["start"],
                        "end": words[i1 + k]["end"],
                    }
                )
    L2 · Modules
    • main.pyTelegram bot: menu, niches, accounts, quick import
    • modules/ai_generator.pyOpenAI script and hook, ElevenLabs voice with fallback
    • modules/transcriber.pyWord-level Whisper, aligned onto the script
    • modules/media_sourcing.pyRoyalty-free footage fetched by keywords
    • modules/video_processor.pyCut plan timed on the voice's pauses
    • modules/visual_effects.pyASS karaoke subtitles, music, FFmpeg render
    L3 · Services
    • Telegram Bot APIInterface, accounts and credits
    • OpenAIScript and hook generation
    • ElevenLabsSynthetic voice, edge-tts fallback
    • Pexels / PixabayRoyalty-free footage libraries
    • FFmpegEditing and 1080×1920 render
    1. L0SurfaceReal capture
    2. L1CodeAligning the words Whisper heard onto the script
    3. L2Modules6 files from the repository
    4. L3Services5 services called

    Design and development, solo

    G2 reads "Go to". G2tiktokWork is the centrepiece of the family: a Telegram bot you give a niche and an idea, and which returns a finished 1080×1920 video. In between, a Python chain: generated script and hook, ElevenLabs speech with a local fallback, royalty-free background footage picked by keywords, Whisper transcription to align every subtitle word, beat-cut editing and FFmpeg rendering.

    In Telegram the menu fits in four buttons: My Niches, New Niche, My Account, Quick Import. Each niche has its JSON configuration: voice, price range, its own footage. Users have accounts and credits in SQLite, backed up daily; the history of renders and used hooks avoids producing the same thing twice.

    Actual state: in service, about sixty videos rendered. Publishing stays manual: that is G2TiktokAutopost's job.

    Python, python-telegram-bot, OpenAI, ElevenLabs, faster-whisper, MoviePy, FFmpeg

  2. LAB/022025-2026Active

    G2Tiktok, the splitter

    A long video goes in, subtitled 9:16 clips come out, sold as credits directly inside Telegram.

    L0 · Surface
    G2Tiktok bot landing page: automatic splitting of long videos into vertical clips.
    L1 · Codecore/database.py
    def check_download_limit(user_id):
        user = get_user(user_id)
        if user["is_premium"]:
            return True, "Premium"
        count = user["free_downloads_count"] or 0
        last_reset = user["last_download_reset"]
        now = datetime.now()
        if last_reset:
            last_reset_dt = datetime.fromisoformat(last_reset)
            if (now - last_reset_dt).total_seconds() > 5 * 3600:
                count = 0
                # ... remise à zéro écrite en base
        if count < 3:
            return True, f"Free ({count+1}/3)"
        return False, "Limite atteinte (3 clips / 5h)."
    L2 · Modules
    • bot/handlers/processing.pyTakes the link, runs the split, sends clips back
    • bot/services/queue_manager.pyPer-user queue, priority, credit deduction
    • bot/services/uploader.pyMTProto upload of large files via Pyrogram
    • core/splitter.py9:16 reframe on blurred background, subtitles, render
    • core/analyzer.pyFinds the segments that stand alone
    • core/database.pyUsers, credits, subscriptions, limits
    L3 · Services
    • Telegram Bot APIInterface, Telegram Stars payments
    • Telegram MTProto (Pyrogram)Files up to two gigabytes
    • yt-dlpYouTube, TikTok, Instagram download
    • Google GeminiVideo analysis and segment selection
    • FFmpegReframe, blur, subtitles, encoding
    1. L0SurfaceReal capture
    2. L1CodeFree tier: three clips per five-hour window
    3. L2Modules6 files from the repository
    4. L3Services5 services called

    Design and development, solo

    The second member of the family takes the problem the other way round: the material already exists as a long video (YouTube, TikTok, Instagram). The bot downloads it, spots the segments that stand on their own, reframes them to 9:16 with a blurred background, burns Whisper subtitles in and returns the clips.

    Two constraints shaped the architecture: heavy files, hence Pyrogram and the MTProto protocol to send up to two gigabytes, and a paid model, hence credits bought with Telegram Stars and a per-user processing queue. The same engine exists as a web dashboard, which served as a test bench before the bot version.

    Python, python-telegram-bot, Pyrogram, yt-dlp, faster-whisper, MoviePy

  3. LAB/032025-2026Active

    G2TiktokAutopost, the publisher

    Publishes video series on several TikTok accounts, driven from Telegram, within the platform's limits.

    L0 · Codetiktok_uploader/tiktok_bot/uploader_core.py
    if part == "\n":
        actions.reset_actions()
        actions.send_keys(Keys.SHIFT + Keys.ENTER).perform()
        time.sleep(0.1)
        continue
    if part.startswith("#"):
        tag_content = part[1:]
        if tag_content:
            actions.reset_actions()
            actions.send_keys("#").perform()
            time.sleep(0.5)
            actions.send_keys(tag_content).perform()
            time.sleep(2.5)  # Wait for dropdown
            actions.send_keys(Keys.ENTER).perform()  # Confirm
    L1 · Modules
    • tiktok_uploader/tiktok_bot/uploader_core.pyDrives Chrome: cookies, typing, waits for the Post button
    • tiktok_uploader/tiktok_bot/bot_interface.pyTelegram menus, series, threaded upload loop
    • tiktok_uploader/tiktok_bot/watcher.pyScans series folders, sorts by part number
    • tiktok_uploader/tiktok_bot/main.pyEntry point, reports newly detected series
    • tiktok_uploader/tiktok_bot/settings.pyEnv config, upload folder validation
    • tiktok_uploader/run.shBootstraps the venv, keeps the Mac awake
    L2 · Services
    • Telegram Bot APIMenus, commands, progress
    • Telegram MTProto (Pyrogram)Fallback download for large videos
    • Selenium / undetected-chromedriverPersistent Chrome profile per account
    • TikTok Creator CenterUpload page driven in the browser
    1. L0CodeHuman-paced caption typing, hashtags confirmed one by one
    2. L1Modules6 files from the repository
    3. L2Services4 services called

    Design and development, solo

    The last link before the viewer's screen. Rendered videos are filed by series, each series has its account, and the bot publishes at the chosen pace by driving a browser with Selenium over saved sessions. It dismisses pop-ups, respects rate limits and moves each published file into a posted/ folder so nothing is ever posted twice.

    No interface beyond Telegram: that is where series status and errors arrive. It is the most fragile tool of the family, because it depends on an interface that is not its own.

    Python, Selenium, Pyrogram, python-telegram-bot

  4. LAB/042026Prototype

    G2Tiktok-Live-inter, the live game

    A guessing game for TikTok Live: the chat guesses, an OBS overlay shows scores and a voice announces rounds.

    L0 · Surface
    OBS overlay of the game: current question, chat guesses and scoreboard.
    L1 · Codemodules/game_engine.py
    if user_msg == correct_answer:
        await self.handle_winner(user, avatar_url)
        return
    if len(user_msg) >= 3:
        ratio = SequenceMatcher(None, user_msg, correct_answer).ratio()
        if ratio >= 0.80:
            now = time.time()
            if now - self.last_near_miss.get(user, 0) < 5:
                return
            self.last_near_miss[user] = now
    L2 · Modules
    • modules/game_engine.pyRounds, fuzzy matching, near-miss cooldown
    • modules/tiktok_client.pyComments, gifts, follows into the engine
    • interfaces/overlay_server.pyaiohttp server and JSON WebSocket broadcast
    • modules/audio_generator.pyOn-demand Edge voice, purged cache
    • overlay/app.jsBrowser overlay: WebSocket, timer, popups
    • main.pyBoots server, engine, client and simulator
    L3 · Services
    • TikTok Live (TikTokLive)Chat, likes, gifts, follows stream
    • EulerStreamSigns the Webcast requests
    • Microsoft Edge TTSFrench voice for the questions
    • OBS (source navigateur)Receives the overlay over WebSocket
    1. L0SurfaceReal capture
    2. L1CodeExact match, near miss and per-player cooldown
    3. L2Modules6 files from the repository
    4. L3Services4 services called

    Design and development, solo

    The G2 family has one member turned toward live. A client listens to a TikTok Live chat, a game engine keeps questions, answers and scores, a WebSocket server pushes state to an overlay the streamer embeds in OBS, and a synthetic voice announces rounds.

    Prototype: questions live in a JSON file, no accounts, no persistence beyond a session. It taught what a chat can do in real time, which fed Roast My Music.

    Python, TikTokLive, WebSocket, edge-tts, OBS

  5. LAB/052025-2026Paused

    G2Trading-safe, the off-video cousin

    Asynchronous trading bot on Solana: new pool detection, automated safety analysis, paper or live execution, Telegram control.

    L0 · Codecore/sniper_analyzer.py
    has_mint_auth = mint_info.get("mint_authority") is not None
    has_freeze_auth = mint_info.get("freeze_authority") is not None
    if has_mint_auth:
        score -= 10  # Pénalité Mint Auth
        details["mint_revoked"] = False
        details["warnings"].append(
            "Mint Authority Active (Dev can create tokens)"
        )
    else:
        score += BONUS_MINT_REVOKED  # +15
        details["mint_revoked"] = True
    if has_freeze_auth:
        score -= 5  # Pénalité Freeze Auth
        details["freeze_revoked"] = False
    else:
        score += BONUS_FREEZE_REVOKED  # +10
        details["freeze_revoked"] = True
    L1 · Modules
    • core/scanner.pyListens to Raydium logs for new pools
    • core/sniper_analyzer.pyScore: authorities, liquidity, buy/sell ratio, holders
    • core/token_health_monitor.pyToken health: volume, structure, time, liquidity
    • core/trader.pyBuy, profit steps, stop, trailing, time exit
    • interface/telegram_bot.pyaiogram dashboard and alerts
    • database/db_manager.pyTrades and positions in SQLite
    L2 · Services
    • Solana RPCLog WebSocket and transactions
    • RaydiumWatched liquidity pools
    • DexScreener APILiquidity, volume, price
    • JupiterQuotes and swaps
    • Telegram Bot APIControl and alerts
    1. L0CodeMint and freeze authorities: score penalty or bonus
    2. L1Modules6 files from the repository
    3. L2Services5 services called

    Design and development, solo

    Same base as the rest of the family, Telegram dashboard included, but a completely different ground. The bot listens to the Solana blockchain over WebSocket to spot new liquidity pools on Raydium, screens every candidate (honeypot, mint and freeze authorities, holder concentration), then executes, in simulation or for real, with post-trade rules: securing part of the gains, liquidating stagnant positions, dynamic stop and target.

    It is shown here for the mechanics: real time, automated safety, asynchronous end to end. Not as advice, and it is paused.

    Python, asyncio, aiogram, Solana, WebSocket

Other experiments

Three projects outside the Telegram base: a live format, a field app, a behavioural health prototype.

  1. LAB/062025-2026Prototype

    Roast My Music

    Platform for streamers: listen to tracks live and rate them with the community, with Twitch and TikTok chat votes in real time.

    L0 · Surface
    Streamer dashboard: now playing, the streamer's grade, Twitch and TikTok averages, locked final score and live activity.
    L1 · Codescripts/live-listener.mjs
    let multiplier = 1;
    if (coins > 0 && coins < 100) multiplier = 1.5;
    else if (coins >= 100 && coins < 500) multiplier = 2;
    else if (coins >= 500) multiplier = 3;
    
    // updateUserScore(platform, user, score)
    users.forEach(u => {
        const rawScore = db.currentSession.scores[platform][u];
        const weight = savedMultipliers[u] || 1; // Default 1
        totalWeightedScore += rawScore * weight;
        totalWeight += weight;
    });
    const avg = totalWeight > 0 ? totalWeightedScore / totalWeight : 0;
    db.currentSession.averages[platform] = parseFloat(avg.toFixed(1));
    L2 · Modules
    • scripts/live-listener.mjsTwitch and TikTok bridge: votes, gifts, averages
    • src/app/api/session/route.jsStreamer score, global score, closing the votes
    • src/components/StreamerDashboard.jsNow playing, score, per-platform averages
    • src/app/overlay/page.jsOBS overlay of the global score
    • src/app/history/page.jsArchived sessions
    • src/lib/db.jsSession and history in JSON
    L3 · Services
    • Twitch IRC (tmi.js)Reads Twitch chat votes
    • TikTok Live (tiktok-live-connector)TikTok live votes and gifts
    • Spotify Web APINow playing and playback control
    • YouTube (lecteur)Track playback
    1. L0SurfaceReal capture
    2. L1CodeA TikTok gift multiplies the vote's weight
    3. L2Modules6 files from the repository
    4. L3Services4 services called

    Design and development, solo

    The starting point is a live-stream format: a streamer listens to tracks or albums with their community and rates them on air. Roast My Music equips that moment. The streamer loads a track, gives a grade from 1 to 10, and the chat votes at the same time: Twitch and TikTok messages are read in real time, weighted (a TikTok gift counts more than a message), and the final score locks when votes close.

    Three surfaces: the streamer dashboard (now playing, their grade, per-platform averages, live chat activity), an overlay to embed in the stream showing the moving score, and a history of sessions. A bridge listens to the chats through tmi.js for Twitch and a TikTok Live connector.

    An older second track explored the classic album page with ratings and reviews. It served to test the rating flow, but the live format is what carries the product: a collective score in real time is what neither Letterboxd nor RateYourMusic does.

    Actual state: working prototype locally, no accounts, sessions stored as JSON. Next step: a shared data model and Twitch authentication to open the tool to other streamers.

    Next.js, TypeScript, Sass, tiktok-live-connector, tmi.js

  2. LAB/072024-2025Paused

    Hall of Arts

    Mobile app for discovering Parisian street art in augmented reality. Diploma project done as a team of three, from an idea I brought.

    L0 · Codesrc/components/Map/MapComponent.js
    initialRegion={userLocation ? undefined : initialRegion}
    onRegionChangeComplete={region => {
      const calculatedZoom = Math.log2(360 / region.latitudeDelta) + 1;
      setZoom(calculatedZoom);
    }}>
    {userLocation && (
      <Marker
        coordinate={{
          latitude: userLocation.latitude,
          longitude: userLocation.longitude,
        }}
        anchor={{x: 0.5, y: 0.5}}>
    L1 · Modules
    • src/components/Navbar/Navbar.jsTabs: feed, map, add, reactions, profile
    • src/api/hooks/useWorkService.jsWorks client: list, detail, create, images
    • src/components/Map/MapComponent.jsMap: GPS watch, works as markers, derived zoom
    • src/components/Map/CustomMarker.jsImage marker sized by the zoom
    • src/screens/AddArt/AddArt.jsForm: photo, Deezer search, publish
    • src/screens/ViewArt/Work: Deezer track, audio playback, photos
    L2 · Services
    • API REST maison (axios)Works, images, creation
    • Deezer APITrack search and previews
    • react-native-mapsNative map and markers
    • GéolocalisationContinuous user position
    1. L0CodeZoom derived from the visible region, anchored marker
    2. L1Modules6 files from the repository
    3. L2Services4 services called

    Project lead and developer, team of three, ESIEE IT diploma project

    The idea was mine: the street is an open-air street art museum with no labels and no guide. Hall of Arts geolocates the works around you on a map, tells each one with text and audio, keeps a timeline of its evolution from community photos, lets artists claim and publish their works, and shows a work in augmented reality where it stands, even after it has been painted over.

    We were three. I held the project lead role, from the brief to the delivery milestones, and the developer role on the React Native app: map and geolocation, work pages with an audio player, ratings and reviews, photo uploads. The first version ran on Firebase and Mapbox; the 2026 rework moves to a dedicated API and integrates the augmented-reality view with ViroReact. The project was presented as our final-year project and counted toward the degree.

    A new version with a rebuilt back end was started in 2026. It is shown here for what it is: a completed school project, currently paused, whose augmented reality on heterogeneous phones remains the most expensive and most useful lesson.

    React Native, Firebase, Mapbox, ViroReact (AR), TypeScript

    Code

  3. LAB/082025Prototype

    Make My Dry

    Behavioural-health app prototype to gradually reduce a consumption, through stages and daily tracking.

    L0 · Codesrc/components/home/DailyChart.tsx
    const DailyChart: React.FC<Props> = ({ entries }) => {
      const dataByHour = Array(24).fill(0);
      entries.forEach((entry) => {
        dataByHour[entry.hour]++;
      });
      const [tooltip, setTooltip] = useState<{ x: number; y: number } | null>(null);
      const [tooltipText, setTooltipText] = useState<string>('');
      const [fadeAnim] = useState(new Animated.Value(0));
      const handlePointClick = (data: any) => {
        const matchedEntry = entries.find((e) => e.hour === Math.floor(data.index));
        if (!matchedEntry) return;
    L1 · Modules
    • src/screens/Home/HomeScreen.tsxEntries state, wires modal and chart
    • src/components/home/AddEntryModal.tsxReason picker, stamped to the hour
    • src/components/home/DailyChart.tsxHourly counter, curve and tooltip
    • src/components/home/WelcomeCard.tsxToday's date and count-based message
    • src/type/Entry.tsxEntry: hour, timestamp, reason
    L2 · Services
    • react-native-chart-kitHourly entries curve
    • React NavigationSingle-screen native stack
    • React NativeiOS and Android runtime
    1. L0CodeTwenty-four hourly buckets for the day's curve
    2. L1Modules5 files from the repository
    3. L2Services3 services called

    Design and development, solo

    A mobile prototype applying a simple method: seven days of observation to establish a baseline, then a staged reduction plan, with a daily log and the reason behind each intake. Charts show the gap between plan and reality.

    It is a behavioural-health app in the same sense as a sleep diary or a smoking-cessation tracker. It extends, on another ground, the work done on Neocortex: giving a person and whoever supports them an honest measuring tool rather than a judgement.

    The prototype never went beyond a local demo: no accounts, no sync, no clinical validation.

    React Native, TypeScript, Reanimated, react-native-chart-kit