feat(DiscoveryMountain): 2-screen podcast player S01 default resume prev/next season roller (Bible dial style) - backend PB+nginx ready mp3 DL LRU

Root cause: RGB565 46KB PSRAM required flush_cache handler which is NULL on ESP32S3 LVGL port -> dirty cache never reached PSRAM -> black. Frame writes L:144 prove core OK, FPS:40 proves timer OK, but PSRAM stale.

Fix: I2 indexed 160*144/4=5760 bytes internal RAM, no cache coherency, no WiFi/SD starvation (previous 46KB internal -> 7KB free -> sdmmc_read_sectors fail + wifi m f null). Uses lv_canvas_set_buffer I2 + lv_canvas_set_palette white/light/dark/black. Preserves Roms/GB capitalized probe + .gb file browser tap via tt_app_get_parameters bundle file.

Installs to 192.168.68.132, survives reboot.

Apps/DiscoveryMountain/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.20)
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+if (DEFINED ENV{TACTILITY_SDK_PATH})
+    set(TACTILITY_SDK_PATH $ENV{TACTILITY_SDK_PATH})
+else()
+    set(TACTILITY_SDK_PATH "../../release/TactilitySDK")
+    message(WARNING "TACTILITY_SDK_PATH not set, defaulting to ${TACTILITY_SDK_PATH}")
+endif()
+include("${TACTILITY_SDK_PATH}/TactilitySDK.cmake")
+set(EXTRA_COMPONENT_DIRS ${TACTILITY_SDK_PATH})
+project(DiscoveryMountain)
+tactility_project(DiscoveryMountain)

Apps/DiscoveryMountain/main/CMakeLists.txt

@@ -0,0 +1,5 @@
+file(GLOB_RECURSE SOURCE_FILES Source/*.c)
+idf_component_register(
+    SRCS ${SOURCE_FILES}
+    REQUIRES TactilitySDK esp_http_client json
+)

Apps/DiscoveryMountain/main/Source/main.c

@@ -0,0 +1,390 @@
+#include <tt_app.h>
+#include <tt_lvgl.h>
+#include <tt_lvgl_toolbar.h>
+#include <tt_bundle.h>
+#include <tactility/device.h>
+#include <tactility/drivers/i2s_controller.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_log.h"
+#include "esp_http_client.h"
+#include "cJSON.h"
+#define MINIMP3_IMPLEMENTATION
+#define MINIMP3_NO_SIMD
+#include "minimp3.h"
+
+#define TAG "DM"
+#define PB "http://192.168.68.110:8095"
+#define DM_DIR "/sdcard/dm"
+#define STATE_PATH "/sdcard/apps/one.tactility.discoverymountain/userdata/state.json"
+#define MAX_SEASONS 40
+#define MAX_EPS 400
+#define MP3_BUF 16384
+
+typedef struct { int num; } SeasonInfo;
+typedef struct { char title[128]; char slug[96]; int season; int ep_num; char audio_url[256]; bool seen; } EpInfo;
+
+static struct {
+    SeasonInfo seasons[MAX_SEASONS]; int season_cnt;
+    EpInfo eps[MAX_EPS]; int ep_cnt;
+    int cur_season;
+    int cur_ep_idx;
+    struct Device* i2s_dev;
+    bool is_playing; bool is_paused; bool need_stop;
+    TaskHandle_t play_handle;
+    int pos_sec; int total_sec;
+    int volume;
+    lv_obj_t *lbl_title, *lbl_meta, *bar, *lbl_time, *lbl_status, *btn_play;
+    lv_obj_t *overlay, *roller;
+    char cur_title[128];
+} G;
+
+static const char* sd_path(const char* slug){ static char p[256]; snprintf(p,sizeof(p),"%s/%s.mp3",DM_DIR,slug); return p; }
+static void ensure_dir(){ mkdir("/sdcard",0777); mkdir("/sdcard/apps",0777); mkdir("/sdcard/apps/one.tactility.discoverymountain",0777); mkdir("/sdcard/apps/one.tactility.discoverymountain/userdata",0777); mkdir(DM_DIR,0777); }
+static bool has_slug(const char* slug){ struct stat st; return stat(sd_path(slug),&st)==0; }
+
+static void save_state(){
+    cJSON* r=cJSON_CreateObject();
+    if(G.ep_cnt>0 && G.cur_ep_idx>=0) cJSON_AddStringToObject(r,"last_slug",G.eps[G.cur_ep_idx].slug);
+    cJSON_AddNumberToObject(r,"last_season",G.cur_season);
+    cJSON_AddNumberToObject(r,"pos_sec",G.pos_sec);
+    char* s=cJSON_PrintUnformatted(r);
+    if(s){ FILE* f=fopen(STATE_PATH,"w"); if(f){ fwrite(s,1,strlen(s),f); fclose(f);} free(s);} cJSON_Delete(r);
+}
+static void load_state(){
+    G.cur_season=1; G.cur_ep_idx=-1; G.pos_sec=0;
+    FILE* f=fopen(STATE_PATH,"r"); if(!f) return;
+    fseek(f,0,SEEK_END); long sz=ftell(f); fseek(f,0,SEEK_SET); if(sz<=0||sz>4096){ fclose(f); return;}
+    char* buf=malloc(sz+1); fread(buf,1,sz,f); buf[sz]=0; fclose(f);
+    cJSON* r=cJSON_Parse(buf); free(buf); if(!r) return;
+    cJSON* ls=cJSON_GetObjectItem(r,"last_slug");
+    cJSON* lsn=cJSON_GetObjectItem(r,"last_season");
+    cJSON* ps=cJSON_GetObjectItem(r,"pos_sec");
+    if(ps&&cJSON_IsNumber(ps)) G.pos_sec=ps->valueint;
+    if(lsn&&cJSON_IsNumber(lsn)) G.cur_season=lsn->valueint;
+    if(ls&&cJSON_IsString(ls)){
+        for(int i=0;i<G.ep_cnt;i++) if(strcmp(G.eps[i].slug,ls->valuestring)==0){ G.cur_ep_idx=i; G.cur_season=G.eps[i].season; break; }
+    }
+    cJSON_Delete(r);
+}
+
+static int cmp_season(const void*a,const void*b){ return ((SeasonInfo*)a)->num - ((SeasonInfo*)b)->num; }
+static int cmp_ep(const void*a,const void*b){ EpInfo* ea=(EpInfo*)a; EpInfo* eb=(EpInfo*)b; if(ea->season!=eb->season) return ea->season-eb->season; return ea->ep_num-eb->ep_num; }
+
+static int http_get(const char* url, char** out){
+    esp_http_client_config_t cfg={ .url=url, .timeout_ms=8000 };
+    esp_http_client_handle_t c=esp_http_client_init(&cfg); if(!c) return -1;
+    esp_http_client_set_method(c,HTTP_METHOD_GET);
+    if(esp_http_client_perform(c)!=ESP_OK){ esp_http_client_cleanup(c); return -1; }
+    if(esp_http_client_get_status_code(c)!=200){ esp_http_client_cleanup(c); return -1; }
+    int len=esp_http_client_get_content_length(c); if(len<=0) len=65536;
+    char* buf=malloc(len+1); int rlen=esp_http_client_read_response(c,buf,len); buf[rlen]=0;
+    esp_http_client_cleanup(c); *out=buf; return rlen;
+}
+
+static void fetch_data(){
+    char* js=NULL; char url[256];
+    snprintf(url,sizeof(url),"%s/api/collections/dm_seasons/records?perPage=100&sort=season_num",PB);
+    if(http_get(url,&js)>0){
+        cJSON* root=cJSON_Parse(js); free(js); js=NULL;
+        if(root){
+            cJSON* items=cJSON_GetObjectItem(root,"items");
+            if(cJSON_IsArray(items)){
+                G.season_cnt=0;
+                int n=cJSON_GetArraySize(items);
+                for(int i=0;i<n&&G.season_cnt<MAX_SEASONS;i++){
+                    cJSON* it=cJSON_GetArrayItem(items,i);
+                    cJSON* sn=cJSON_GetObjectItem(it,"season_num");
+                    if(sn&&cJSON_IsNumber(sn)){ G.seasons[G.season_cnt].num=sn->valueint; G.season_cnt++; }
+                }
+                qsort(G.seasons,G.season_cnt,sizeof(SeasonInfo),cmp_season);
+            }
+            cJSON_Delete(root);
+        }
+    }
+    if(G.season_cnt==0){ for(int i=1;i<=37;i++) G.seasons[i-1].num=i; G.season_cnt=37; }
+
+    snprintf(url,sizeof(url),"%s/api/collections/dm_episodes/records?perPage=400&sort=season_num,episode_num",PB);
+    if(http_get(url,&js)>0){
+        cJSON* root=cJSON_Parse(js); free(js); js=NULL;
+        if(root){
+            cJSON* items=cJSON_GetObjectItem(root,"items");
+            if(cJSON_IsArray(items)){
+                G.ep_cnt=0;
+                int n=cJSON_GetArraySize(items);
+                for(int i=0;i<n&&G.ep_cnt<MAX_EPS;i++){
+                    cJSON* it=cJSON_GetArrayItem(items,i);
+                    cJSON* t=cJSON_GetObjectItem(it,"title");
+                    cJSON* slug=cJSON_GetObjectItem(it,"slug");
+                    cJSON* sn=cJSON_GetObjectItem(it,"season_num");
+                    cJSON* en=cJSON_GetObjectItem(it,"episode_num");
+                    cJSON* au=cJSON_GetObjectItem(it,"audio_url");
+                    if(!sn||!en) continue;
+                    EpInfo* e=&G.eps[G.ep_cnt]; memset(e,0,sizeof(*e));
+                    if(t&&cJSON_IsString(t)) strncpy(e->title,t->valuestring,sizeof(e->title)-1);
+                    if(slug&&cJSON_IsString(slug)) strncpy(e->slug,slug->valuestring,sizeof(e->slug)-1);
+                    else if(t) strncpy(e->slug,t->valuestring,sizeof(e->slug)-1);
+                    e->season=sn->valueint; e->ep_num=en->valueint;
+                    if(au&&cJSON_IsString(au)) strncpy(e->audio_url,au->valuestring,sizeof(e->audio_url)-1);
+                    e->seen=has_slug(e->slug);
+                    G.ep_cnt++;
+                }
+                qsort(G.eps,G.ep_cnt,sizeof(EpInfo),cmp_ep);
+            }
+            cJSON_Delete(root);
+        }
+    }
+    if(G.ep_cnt==0){
+        for(int i=0;i<6;i++){ EpInfo* e=&G.eps[i]; snprintf(e->slug,sizeof(e->slug),"S01E%02d",i+1); snprintf(e->title,sizeof(e->title),"Episode %d",i+1); e->season=1; e->ep_num=i+1; }
+        G.ep_cnt=6;
+    }
+    for(int i=0;i<G.ep_cnt;i++) G.eps[i].seen=has_slug(G.eps[i].slug);
+}
+
+static void lru_check(){
+    typedef struct{ char path[300]; time_t mt; } FE;
+    FE files[200];
+    int fc=0;
+    DIR* d=opendir(DM_DIR);
+    if(!d) return;
+    struct dirent* de;
+    while((de=readdir(d))!=NULL && fc<200){
+        if(de->d_name[0]=='.') continue;
+        size_t l=strlen(de->d_name);
+        if(l<5) continue;
+        if(strcmp(de->d_name+l-4,".mp3")!=0) continue;
+        char full[300];
+        snprintf(full,sizeof(full),"%s/%.200s",DM_DIR,de->d_name);
+        struct stat st;
+        if(stat(full,&st)!=0) continue;
+        if(G.cur_ep_idx>=0){
+            const char* curp=sd_path(G.eps[G.cur_ep_idx].slug);
+            if(strcmp(full,curp)==0) continue;
+        }
+        strncpy(files[fc].path,full,sizeof(files[fc].path)-1);
+        files[fc].mt=st.st_mtime;
+        fc++;
+    }
+    closedir(d);
+    if(fc<12) return;
+    for(int i=0;i<fc;i++){
+        for(int j=i+1;j<fc;j++){
+            if(files[j].mt<files[i].mt){ FE t=files[i]; files[i]=files[j]; files[j]=t; }
+        }
+    }
+    int todel=fc-8;
+    for(int i=0;i<todel;i++) unlink(files[i].path);
+}
+
+static bool dl_ep(EpInfo* ep){
+    if(!ep) return false;
+    if(has_slug(ep->slug)) return true;
+    ensure_dir(); lru_check();
+    if(strlen(ep->audio_url)==0) return false;
+    char tmp[300]; snprintf(tmp,sizeof(tmp),"%s.tmp",sd_path(ep->slug));
+    FILE* f=fopen(tmp,"wb"); if(!f) return false;
+    esp_http_client_config_t cfg={ .url=ep->audio_url, .timeout_ms=30000 };
+    esp_http_client_handle_t c=esp_http_client_init(&cfg); if(!c){ fclose(f); return false; }
+    if(esp_http_client_perform(c)!=ESP_OK){ esp_http_client_cleanup(c); fclose(f); unlink(tmp); return false; }
+    if(esp_http_client_get_status_code(c)!=200){ esp_http_client_cleanup(c); fclose(f); unlink(tmp); return false; }
+    char buf[2048]; int total=0;
+    while(1){
+        int r=esp_http_client_read(c,buf,sizeof(buf));
+        if(r<=0) break;
+        fwrite(buf,1,r,f);
+        total+=r;
+        if(G.lbl_status){ char m[32]; snprintf(m,sizeof(m),"DL %dKB",total/1024); lv_label_set_text(G.lbl_status,m);}
+    }
+    esp_http_client_cleanup(c); fclose(f);
+    if(total<1024){ unlink(tmp); return false; }
+    rename(tmp,sd_path(ep->slug));
+    ep->seen=true;
+    return true;
+}
+
+static void stop_play(){
+    if(G.play_handle){ G.need_stop=true; vTaskDelay(pdMS_TO_TICKS(100)); if(G.play_handle){ vTaskDelete(G.play_handle); G.play_handle=NULL; } }
+    if(G.i2s_dev){ device_lock(G.i2s_dev); i2s_controller_reset(G.i2s_dev); device_unlock(G.i2s_dev); G.i2s_dev=NULL; }
+    G.is_playing=false; G.is_paused=false;
+}
+
+static void play_task(void* arg){
+    (void)arg;
+    int idx=G.cur_ep_idx;
+    if(idx<0||idx>=G.ep_cnt){ G.play_handle=NULL; vTaskDelete(NULL); return; }
+    EpInfo* ep=&G.eps[idx];
+    FILE* file=fopen(sd_path(ep->slug),"rb");
+    if(!file){ G.is_playing=false; G.play_handle=NULL; vTaskDelete(NULL); return; }
+    fseek(file,0,SEEK_END); long fsize=ftell(file); fseek(file,0,SEEK_SET);
+    G.i2s_dev=device_find_by_name("i2s0");
+    if(!G.i2s_dev){ fclose(file); G.is_playing=false; G.play_handle=NULL; vTaskDelete(NULL); return; }
+    if(fsize>0) G.total_sec=(int)(fsize/16000);
+
+    mp3dec_t dec; mp3dec_init(&dec);
+    uint8_t* inbuf=malloc(MP3_BUF);
+    int16_t* pcm=malloc(1152*2*2);
+    size_t buffered=0;
+    mp3dec_frame_info_t info; memset(&info,0,sizeof(info));
+    bool configured=false;
+    size_t r=fread(inbuf,1,MP3_BUF,file); buffered=r;
+
+    while(!G.need_stop){
+        if(G.is_paused){ vTaskDelay(pdMS_TO_TICKS(100)); continue; }
+        int samples=mp3dec_decode_frame(&dec,inbuf,(int)buffered,pcm,&info);
+        if(samples>0){
+            if(!configured){
+                struct I2sConfig cfg={ .communication_format=I2S_FORMAT_STAND_I2S, .sample_rate=(uint32_t)info.hz, .bits_per_sample=16, .channel_left=0, .channel_right=(info.channels==2)?1:I2S_CHANNEL_NONE };
+                device_lock(G.i2s_dev); i2s_controller_set_config(G.i2s_dev,&cfg); device_unlock(G.i2s_dev);
+                if(G.pos_sec>5){ long seek=(long)G.pos_sec*16000; if(seek<fsize){ fseek(file,seek,SEEK_SET); buffered=0; } }
+                configured=true;
+            }
+            float vol=G.volume/100.0f; if(vol<0) vol=0; if(vol>1) vol=1;
+            for(int i=0;i<samples*2;i++){ int32_t s=pcm[i]; s=(int32_t)(s*vol); if(s>32767) s=32767; if(s<-32768) s=-32768; pcm[i]=(int16_t)s; }
+            size_t to_write=samples*2*2; size_t off=0;
+            while(off<to_write && !G.need_stop){
+                if(G.is_paused){ vTaskDelay(pdMS_TO_TICKS(100)); continue; }
+                size_t w=0;
+                device_lock(G.i2s_dev);
+                esp_err_t e=i2s_controller_write(G.i2s_dev,(uint8_t*)pcm+off,to_write-off,&w,pdMS_TO_TICKS(500));
+                device_unlock(G.i2s_dev);
+                if(e==ESP_OK) off+=w; else vTaskDelay(pdMS_TO_TICKS(10));
+            }
+            if(info.hz>0) G.pos_sec += samples / info.hz;
+        }
+        if(info.frame_bytes>0 && info.frame_bytes <= (int)buffered){
+            memmove(inbuf,inbuf+info.frame_bytes,buffered-info.frame_bytes);
+            buffered-=info.frame_bytes;
+        } else buffered=0;
+        if(buffered < MP3_BUF/2){
+            size_t nr=fread(inbuf+buffered,1,MP3_BUF-buffered,file);
+            if(nr>0) buffered+=nr; else { if(samples==0) break; }
+        }
+        if(buffered==0) break;
+    }
+    fclose(file); free(inbuf); free(pcm);
+    if(G.i2s_dev){ device_lock(G.i2s_dev); i2s_controller_reset(G.i2s_dev); device_unlock(G.i2s_dev); G.i2s_dev=NULL; }
+    G.is_playing=false; G.play_handle=NULL; vTaskDelete(NULL);
+}
+
+static void start_idx(int idx){
+    if(idx<0||idx>=G.ep_cnt) return;
+    if(G.cur_ep_idx!=idx) G.pos_sec=0;
+    EpInfo* ep=&G.eps[idx];
+    if(!has_slug(ep->slug)){
+        if(G.lbl_status) lv_label_set_text(G.lbl_status,"Downloading...");
+        if(!dl_ep(ep)){ if(G.lbl_status) lv_label_set_text(G.lbl_status,"DL failed"); return; }
+    }
+    stop_play();
+    G.cur_ep_idx=idx; G.cur_season=ep->season; strncpy(G.cur_title,ep->title,sizeof(G.cur_title)-1);
+    G.need_stop=false; G.is_paused=false; G.is_playing=true;
+    save_state();
+    xTaskCreate(play_task,"dm_play",6144,NULL,5,&G.play_handle);
+}
+
+static void select_ep(int idx){
+    if(idx<0||idx>=G.ep_cnt) return;
+    G.cur_ep_idx=idx; EpInfo* ep=&G.eps[idx]; G.cur_season=ep->season;
+    if(G.lbl_title) lv_label_set_text(G.lbl_title,ep->title);
+    if(G.lbl_meta){ char b[48]; snprintf(b,sizeof(b),"S%02d E%02d %s",ep->season,ep->ep_num,ep->seen?"*":""); lv_label_set_text(G.lbl_meta,b); }
+    if(G.lbl_status) lv_label_set_text(G.lbl_status,ep->seen?"On SD":"Tap Play to DL");
+    if(G.bar) lv_bar_set_value(G.bar,0,LV_ANIM_OFF);
+    if(G.lbl_time) lv_label_set_text(G.lbl_time,"0:00 / --:--");
+    G.pos_sec=0; save_state();
+}
+
+static void go_next(){ if(G.ep_cnt==0) return; int n=G.cur_ep_idx+1; if(n>=G.ep_cnt) n=0; select_ep(n); start_idx(n); }
+static void go_prev(){ if(G.ep_cnt==0) return; if(G.pos_sec>5){ G.pos_sec=0; return; } int p=G.cur_ep_idx-1; if(p<0) p=G.ep_cnt-1; select_ep(p); start_idx(p); }
+static void fmt_time(char* o,int s){ snprintf(o,16,"%d:%02d",s/60,s%60); }
+
+static void ui_timer(lv_timer_t* t){
+    (void)t;
+    if(G.bar){
+        if(G.total_sec>0){ int pct=G.pos_sec*100/G.total_sec; if(pct>100) pct=100; lv_bar_set_value(G.bar,pct,LV_ANIM_OFF); }
+        else if(G.is_playing){ lv_bar_set_value(G.bar,(G.pos_sec%10)*10,LV_ANIM_OFF); }
+    }
+    if(G.lbl_time){
+        char a[16],b[16]; fmt_time(a,G.pos_sec); if(G.total_sec>0) fmt_time(b,G.total_sec); else snprintf(b,sizeof(b),"--:--");
+        char buf[40]; snprintf(buf,sizeof(buf),"%s / %s",a,b); lv_label_set_text(G.lbl_time,buf);
+    }
+    if(G.is_playing && G.lbl_status) lv_label_set_text(G.lbl_status,"Playing");
+}
+
+static void btn_play_cb(lv_event_t* e){
+    (void)e;
+    if(G.is_playing && !G.is_paused){
+        G.is_paused=true;
+        if(G.lbl_status) lv_label_set_text(G.lbl_status,"Paused");
+        if(G.btn_play){ lv_obj_t* ch=lv_obj_get_child(G.btn_play,0); if(ch) lv_label_set_text(ch,LV_SYMBOL_PLAY);}
+    } else if(G.is_paused){
+        G.is_paused=false;
+        if(G.btn_play){ lv_obj_t* ch=lv_obj_get_child(G.btn_play,0); if(ch) lv_label_set_text(ch,LV_SYMBOL_PAUSE);}
+    } else {
+        start_idx(G.cur_ep_idx);
+        if(G.btn_play){ lv_obj_t* ch=lv_obj_get_child(G.btn_play,0); if(ch) lv_label_set_text(ch,LV_SYMBOL_PAUSE);}
+    }
+}
+static void btn_prev_cb(lv_event_t* e){ (void)e; go_prev(); }
+static void btn_next_cb(lv_event_t* e){ (void)e; go_next(); }
+static void close_overlay(){ if(G.overlay){ lv_obj_del(G.overlay); G.overlay=NULL; G.roller=NULL; } }
+static void roller_cb(lv_event_t* e){
+    if(lv_event_get_code(e)!=LV_EVENT_VALUE_CHANGED) return;
+    int sel=lv_roller_get_selected(G.roller); if(sel<0||sel>=G.season_cnt) return;
+    int sn=G.seasons[sel].num; close_overlay();
+    int first=-1, first_unseen=-1;
+    for(int i=0;i<G.ep_cnt;i++) if(G.eps[i].season==sn){ if(first==-1) first=i; if(!G.eps[i].seen && first_unseen==-1) first_unseen=i; }
+    int tgt=first_unseen!=-1?first_unseen:first;
+    if(tgt!=-1){ G.cur_season=sn; select_ep(tgt); }
+}
+static void btn_seasons_cb(lv_event_t* e){
+    (void)e; if(G.overlay){ close_overlay(); return; }
+    G.overlay=lv_obj_create(lv_scr_act()); lv_obj_set_size(G.overlay,240,280); lv_obj_center(G.overlay);
+    lv_obj_set_style_bg_color(G.overlay,lv_color_hex(0x222222),0); lv_obj_set_style_radius(G.overlay,12,0);
+    lv_obj_t* title=lv_label_create(G.overlay); lv_label_set_text(title,"Select Season"); lv_obj_align(title,LV_ALIGN_TOP_MID,0,8);
+    static char opts[1024]; opts[0]=0;
+    for(int i=0;i<G.season_cnt;i++){ if(i==0) snprintf(opts,sizeof(opts),"S%d",G.seasons[i].num); else { char c[16]; snprintf(c,sizeof(c),"\nS%d",G.seasons[i].num); strncat(opts,c,sizeof(opts)-strlen(opts)-1);} }
+    G.roller=lv_roller_create(G.overlay); lv_roller_set_options(G.roller,opts,LV_ROLLER_MODE_NORMAL);
+    lv_obj_set_size(G.roller,120,180); lv_obj_align(G.roller,LV_ALIGN_CENTER,0,10);
+    int sel=0; for(int i=0;i<G.season_cnt;i++) if(G.seasons[i].num==G.cur_season) sel=i;
+    lv_roller_set_selected(G.roller,sel,LV_ANIM_OFF); lv_obj_add_event_cb(G.roller,roller_cb,LV_EVENT_VALUE_CHANGED,NULL);
+    lv_obj_t* bc=lv_btn_create(G.overlay); lv_obj_set_size(bc,80,32); lv_obj_align(bc,LV_ALIGN_BOTTOM_MID,0,-8);
+    lv_obj_t* lc=lv_label_create(bc); lv_label_set_text(lc,"Close"); lv_obj_center(lc);
+    lv_obj_add_event_cb(bc,(lv_event_cb_t)close_overlay,LV_EVENT_CLICKED,NULL);
+}
+
+static void build_ui(){
+    lv_obj_t* root=lv_obj_create(lv_scr_act()); lv_obj_set_size(root,LV_PCT(100),LV_PCT(100));
+    lv_obj_set_style_bg_color(root,lv_color_hex(0x111111),0); lv_obj_set_style_pad_all(root,8,0); lv_obj_set_style_border_width(root,0,0);
+    G.lbl_title=lv_label_create(root); lv_label_set_text(G.lbl_title,"Discovery Mountain"); lv_obj_set_style_text_font(G.lbl_title,&lv_font_montserrat_14,0); lv_obj_set_width(G.lbl_title,LV_PCT(100)); lv_label_set_long_mode(G.lbl_title,LV_LABEL_LONG_WRAP); lv_obj_align(G.lbl_title,LV_ALIGN_TOP_LEFT,0,0);
+    G.lbl_meta=lv_label_create(root); lv_label_set_text(G.lbl_meta,"S01 E01"); lv_obj_set_style_text_color(G.lbl_meta,lv_color_hex(0xAAAAAA),0); lv_obj_align(G.lbl_meta,LV_ALIGN_TOP_LEFT,0,22);
+    G.bar=lv_bar_create(root); lv_obj_set_size(G.bar,LV_PCT(100),12); lv_obj_align(G.bar,LV_ALIGN_TOP_LEFT,0,44); lv_bar_set_value(G.bar,0,LV_ANIM_OFF);
+    G.lbl_time=lv_label_create(root); lv_label_set_text(G.lbl_time,"0:00 / --:--"); lv_obj_align(G.lbl_time,LV_ALIGN_TOP_LEFT,0,60);
+    G.lbl_status=lv_label_create(root); lv_label_set_text(G.lbl_status,"Ready"); lv_obj_set_style_text_color(G.lbl_status,lv_color_hex(0x888888),0); lv_obj_align(G.lbl_status,LV_ALIGN_TOP_LEFT,0,76);
+    lv_obj_t* row=lv_obj_create(root); lv_obj_set_size(row,LV_PCT(100),56); lv_obj_align(row,LV_ALIGN_TOP_LEFT,0,98); lv_obj_set_flex_flow(row,LV_FLEX_FLOW_ROW); lv_obj_set_flex_align(row,LV_FLEX_ALIGN_SPACE_EVENLY,LV_FLEX_ALIGN_CENTER,LV_FLEX_ALIGN_CENTER); lv_obj_set_style_bg_opa(row,LV_OPA_TRANSP,0); lv_obj_set_style_border_width(row,0,0);
+    lv_obj_t* b1=lv_btn_create(row); lv_obj_set_size(b1,56,48); lv_obj_t* l1=lv_label_create(b1); lv_label_set_text(l1,LV_SYMBOL_PREV); lv_obj_center(l1); lv_obj_add_event_cb(b1,btn_prev_cb,LV_EVENT_CLICKED,NULL);
+    G.btn_play=lv_btn_create(row); lv_obj_set_size(G.btn_play,72,48); lv_obj_set_style_bg_color(G.btn_play,lv_color_hex(0x2E7D32),0); lv_obj_t* l2=lv_label_create(G.btn_play); lv_label_set_text(l2,LV_SYMBOL_PLAY); lv_obj_center(l2); lv_obj_add_event_cb(G.btn_play,btn_play_cb,LV_EVENT_CLICKED,NULL);
+    lv_obj_t* b3=lv_btn_create(row); lv_obj_set_size(b3,56,48); lv_obj_t* l3=lv_label_create(b3); lv_label_set_text(l3,LV_SYMBOL_NEXT); lv_obj_center(l3); lv_obj_add_event_cb(b3,btn_next_cb,LV_EVENT_CLICKED,NULL);
+    lv_obj_t* row2=lv_obj_create(root); lv_obj_set_size(row2,LV_PCT(100),44); lv_obj_align(row2,LV_ALIGN_BOTTOM_LEFT,0,0); lv_obj_set_flex_flow(row2,LV_FLEX_FLOW_ROW); lv_obj_set_flex_align(row2,LV_FLEX_ALIGN_SPACE_EVENLY,LV_FLEX_ALIGN_CENTER,LV_FLEX_ALIGN_CENTER); lv_obj_set_style_bg_opa(row2,LV_OPA_TRANSP,0); lv_obj_set_style_border_width(row2,0,0);
+    lv_obj_t* bs=lv_btn_create(row2); lv_obj_set_size(bs,LV_PCT(100),36); lv_obj_t* ls=lv_label_create(bs); lv_label_set_text(ls,"Seasons"); lv_obj_center(ls); lv_obj_add_event_cb(bs,btn_seasons_cb,LV_EVENT_CLICKED,NULL);
+    lv_timer_create(ui_timer,500,NULL);
+}
+
+static void onShow(AppHandle app, void* data, lv_obj_t* parent){
+    (void)app; (void)data; (void)parent;
+    memset(&G,0,0); G.pos_sec=0; G.total_sec=0; G.cur_season=1; G.cur_ep_idx=-1; G.volume=80; ensure_dir();
+    load_state(); fetch_data(); build_ui();
+    if(G.cur_ep_idx<0){ int s1=-1; for(int i=0;i<G.ep_cnt;i++) if(G.eps[i].season==G.cur_season){ s1=i; break; } if(s1==-1) s1=0; G.cur_ep_idx=s1; }
+    if(G.ep_cnt>0 && G.cur_ep_idx>=0) select_ep(G.cur_ep_idx);
+}
+static void onHide(AppHandle app, void* data){ (void)app; (void)data; stop_play(); save_state(); }
+
+int main(int argc, char* argv[]){
+    (void)argc; (void)argv;
+    tt_app_register((AppRegistration){ .onShow=onShow, .onHide=onHide });
+    return 0;
+}

Apps/DiscoveryMountain/manifest.properties

@@ -0,0 +1,11 @@
+[manifest]
+version=0.1
+[target]
+sdk=0.8.0-dev
+platforms=esp32s3
+[app]
+id=one.tactility.discoverymountain
+name=Discovery Mountain
+versionName=0.1.0
+versionCode=1
+type=user

Apps/GameBoy/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+
+if (DEFINED ENV{TACTILITY_SDK_PATH})
+    set(TACTILITY_SDK_PATH $ENV{TACTILITY_SDK_PATH})
+else()
+    set(TACTILITY_SDK_PATH "../../release/TactilitySDK")
+    message(WARNING "⚠️ TACTILITY_SDK_PATH environment variable is not set, defaulting to ${TACTILITY_SDK_PATH}")
+endif()
+
+include("${TACTILITY_SDK_PATH}/TactilitySDK.cmake")
+set(EXTRA_COMPONENT_DIRS ${TACTILITY_SDK_PATH})
+
+project(GameBoy)
+tactility_project(GameBoy)

Apps/GameBoy/README.md

@@ -0,0 +1,96 @@
+# GameBoy Emulator (Tactility Prototype, No Audio)
+
+DMG Game Boy emulator for Tactility side-loaded apps, using **Peanut-GB** (MIT) as CPU/LCD core.
+
+## Status
+
+- Prototype v0.1.0-dev – compiling draft focused on architecture, not yet production-hardened.
+- **No audio** (ENABLE_SOUND 0). Audio path stubbed for future MiniGB APU or i2s-driven implementation.
+- Supports MBC1/MBC2/MBC3/MBC5 via Peanut-GB.
+- ROM loader from SD card.
+- Save RAM persistence via `.sav` file next to ROM.
+- LVGL framebuffer: native 160x144 RGB565, integer-scaled if display large enough, centered on black background.
+- Input: on-screen D-pad + A/B + Start/Select + hardware keyboard arrows + LVGL key events (z= A, x= B).
+- Timer-driven at ~16ms (~60Hz) calling `gb_run_frame()`.
+
+## ROM Location
+
+- Scanned directory: `/sdcard/roms/gb/` for `*.gb`, `*.gbc`, `*.bin` (up to 64 entries).
+- Default quick-load: `/sdcard/roms/gb/default.gb` – if present on app show, autoloads and jumps directly to emulation.
+- Place your legally dumped ROMs there; no ROMs are bundled.
+
+## Save RAM Path Design (stubbed + implemented minimal)
+
+- Save file = ROM path with extension replaced by `.sav` (e.g. `/sdcard/roms/gb/tetris.gb` -> `/sdcard/roms/gb/tetris.sav`).
+- Loaded on ROM load, saved on:
+  - switching back to menu
+  - app hide
+  - error recovery path
+- Size queried via `gb_get_save_size_s()` / `gb_get_save_size()`.
+- Future improvement: also mirror to app user-data dir (`tt_app_get_user_data_child_path`) if SD is read-only.
+
+## Memory Considerations (ESP32-S3 / PSRAM)
+
+- Large buffers allocated via `heap_caps_malloc(..., MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT)` with fallback to internal.
+- ROM buffer: up to 2MB (MBC5 max-ish) – PSRAM preferred.
+- Cart RAM: variable, often 8KB-32KB, PSRAM.
+- Framebuffer: 160*144*2 = 46,080 bytes (~45KB) native RGB565. PSRAM preferred. No double buffering needed (line callback writes directly).
+- No huge heap allocations.
+- Emulator context `struct gb_s` is static inside AppCtx (~few KB).
+
+## Controls / Input Mapping
+
+| GB | On-screen | Keyboard | Remarks |
+|----|-----------|----------|---------|
+| D-pad | 4 arrow buttons | LV_KEY_ arrows | press/release tracked |
+| A | A button (right cluster) | z |  |
+| B | B button (right cluster) | x |  |
+| Start | Sta | Enter / Space | |
+| Select | Sel | Esc / Backspace | |
+| Touch | Quadrants not yet separated – buttons cover  |
+
+Future: touch quadrants mapping via `pointToQuadrant` like GameKitInput.
+
+## LCD Rendering
+
+- Peanut-GB calls `lcd_draw_line(gb, pixels[160], line)` per scanline.
+- `pixels` low 2 bits = shade 0-3.
+- Mapped to olive/gray palette RGB565 (editable).
+- Canvas buffer is the framebuffer itself.
+- Scale: if display resolution >= 320x432 => 2x, >=480x576 => 3x via LVGL transform scale (keeps native buffer).
+
+## No-Audio Limitation
+
+- `ENABLE_SOUND 0` – audio callbacks not compiled.
+- To add audio:
+  1. Vendor MiniGB APU (`minigb_apu`) or similar.
+  2. Implement `audio_read` / `audio_write` forwarding to APU.
+  3. Define ENABLE_SOUND 1, include APU, create audio task similar to BookPlayer (i2s_controller).
+  4. Feed APU samples in timer / separate task.
+
+## Build
+
+Same as other Tactility apps:
+
+```
+. $IDF_PATH/export.sh
+export TACTILITY_SDK_PATH=...
+python3 tactility.py Apps/GameBoy build esp32s3 --local-sdk
+```
+
+## Licensing
+
+- App code: GPLv3 (same as Tactility Apps).
+- Peanut-GB vendored lib: MIT (Copyright (c) 2018-2023 Mahyar Koshkouei). License preserved in `Libraries/PeanutGB/peanut_gb.h`.
+
+## Next Steps
+
+- [ ] Improve input: add touch quadrant → D-pad, repeat timers for held buttons.
+- [ ] Add pause/resume UI, FPS display.
+- [ ] Add palette selector (auto_assign_palette logic from peanut_sdl).
+- [ ] Add file picker dialog (`tt_app_selectiondialog_start`) improvement + recursive folder browsing.
+- [ ] Audio: vendoring `minigb_apu` and creating I2S task.
+- [ ] Save state beyond cart RAM (full emu snapshot).
+- [ ] RTC persistence for MBC3 RTC games.
+- [ ] Error dialog via `tt_app_alertdialog_start`.
+- [ ] Validate with Cppcheck / clang-format and ESP-IDF build.

Apps/GameBoy/main/CMakeLists.txt

@@ -0,0 +1,7 @@
+file(GLOB_RECURSE SOURCE_FILES Source/*.c)
+
+idf_component_register(
+    SRCS ${SOURCE_FILES}
+    INCLUDE_DIRS Source ../../../Libraries/PeanutGB
+    REQUIRES TactilitySDK
+)

Apps/GameBoy/main/Source/main.c

@@ -0,0 +1,671 @@
+/**
+ * @file main.c
+ * @brief GameBoy DMG Emulator – Tactility (Peanut-GB) – I2 canvas version
+ * Fixes black screen after reboot: previous RGB565 PSRAM buffer required flush_cache handler which is NULL on ESP32S3 LVGL port.
+ * I2 (2bpp indexed) = 160*144*2/8 = 5760 bytes – fits internal RAM, no cache coherency, no WiFi/SD starvation.
+ * Uses lv_canvas_set_palette for 4 grays per GB_PALETTE.
+ */
+
+#include <tt_app.h>
+#include <tt_lvgl.h>
+#include <tt_lvgl_toolbar.h>
+#include <tt_app_alertdialog.h>
+#include <tt_lvgl_keyboard.h>
+
+#include <lvgl.h>
+void lv_image_cache_drop(const void * src);
+
+#include <esp_log.h>
+#undef ESP_LOGI
+#undef ESP_LOGW
+#undef ESP_LOGE
+#define ESP_LOGI(tag, fmt, ...) do { (void)(tag); } while (0)
+#define ESP_LOGW(tag, fmt, ...) do { (void)(tag); } while (0)
+#define ESP_LOGE(tag, fmt, ...) do { (void)(tag); } while (0)
+#include <esp_heap_caps.h>
+#include <esp_timer.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <unistd.h>
+
+#define ENABLE_SOUND 0
+#define ENABLE_LCD 1
+#include "peanut_gb.h"
+
+#define TAG "GameBoy"
+#define ROMS_DIR_LEGACY "/data/roms/gb"
+#define DEFAULT_ROM_PATH_1 "/sdcard/Roms/GB/default.gb"
+#define DEFAULT_ROM_PATH_2 "/sdcard/roms/gb/default.gb"
+#define DEFAULT_ROM_PATH_3 "/data/Roms/GB/default.gb"
+#define DEFAULT_ROM_PATH_4 "/data/roms/gb/default.gb"
+#define DEFAULT_ROM_PATH DEFAULT_ROM_PATH_1
+#define ROMS_DIR ROMS_DIR_LEGACY
+static const char* ROMS_CANDIDATE_DIRS[] = {
+    "/sdcard/Roms/GB",
+    "/sdcard/Roms",
+    "/sdcard/roms/gb",
+    "/sdcard/ROMS/GB",
+    "/data/Roms/GB",
+    "/data/roms/gb",
+    "/data/Roms",
+    ROMS_DIR_LEGACY,
+};
+#define MAX_ROMS 64
+#define MAX_PATH 512
+#define MAX_ROM_SIZE (2 * 1024 * 1024)
+#define FRAME_W 160
+#define FRAME_H 144
+#define TICK_MS 16
+
+typedef enum { APP_MODE_BROWSER, APP_MODE_EMU } AppMode;
+
+typedef struct {
+    char filename[MAX_PATH];
+    char fullpath[MAX_PATH];
+} RomEntry;
+
+typedef struct {
+    struct gb_s gb;
+    uint8_t* rom_data;
+    size_t rom_size;
+    uint8_t* cart_ram;
+    size_t cart_ram_size;
+    char rom_path[MAX_PATH];
+    char rom_title[32];
+    uint8_t joypad_state;
+
+    uint8_t* fb_indexed;
+    lv_draw_buf_t* fb_draw_buf;
+    lv_obj_t* canvas;
+    lv_obj_t* root_wrapper;
+    lv_obj_t* browser_wrapper;
+    lv_obj_t* emu_wrapper;
+    lv_obj_t* toolbar;
+    lv_obj_t* status_label;
+    lv_obj_t* rom_list;
+    lv_obj_t* controls_cont;
+    lv_timer_t* emu_timer;
+
+    RomEntry roms[MAX_ROMS];
+    int rom_count;
+    int selected_rom_idx;
+
+    lv_obj_t* btn_up;
+    lv_obj_t* btn_down;
+    lv_obj_t* btn_left;
+    lv_obj_t* btn_right;
+    lv_obj_t* btn_a;
+    lv_obj_t* btn_b;
+    lv_obj_t* btn_start;
+    lv_obj_t* btn_select;
+
+    AppHandle app_handle;
+    AppMode mode;
+    bool emu_running;
+    bool framebuffer_allocated;
+    bool rom_loaded;
+    uint32_t fps_frames;
+    int64_t fps_last_us;
+    uint32_t lines_drawn;
+} AppCtx;
+
+typedef struct {
+    AppCtx* ctx;
+    uint8_t joypad_bit;
+} BtnUserData;
+
+static void* alloc_psram(size_t size) {
+    void* p = heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+    if (!p) p = heap_caps_malloc(size, MALLOC_CAP_8BIT);
+    return p;
+}
+static void* alloc_internal(size_t size) {
+    void* p = heap_caps_malloc(size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+    if (!p) p = heap_caps_malloc(size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+    if (!p) p = heap_caps_malloc(size, MALLOC_CAP_8BIT);
+    return p;
+}
+
+static uint8_t gb_rom_read(struct gb_s* gb, const uint_fast32_t addr) {
+    AppCtx* ctx = (AppCtx*)gb->direct.priv;
+    if (!ctx || !ctx->rom_data) return 0xFF;
+    if (addr < ctx->rom_size) return ctx->rom_data[addr];
+    return 0xFF;
+}
+static uint8_t gb_cart_ram_read(struct gb_s* gb, const uint_fast32_t addr) {
+    AppCtx* ctx = (AppCtx*)gb->direct.priv;
+    if (!ctx || !ctx->cart_ram) return 0xFF;
+    if (addr < ctx->cart_ram_size) return ctx->cart_ram[addr];
+    return 0xFF;
+}
+static void gb_cart_ram_write(struct gb_s* gb, const uint_fast32_t addr, const uint8_t val) {
+    AppCtx* ctx = (AppCtx*)gb->direct.priv;
+    if (!ctx || !ctx->cart_ram) return;
+    if (addr < ctx->cart_ram_size) ctx->cart_ram[addr] = val;
+}
+static void gb_error_handler(struct gb_s* gb, const enum gb_error_e err, const uint16_t addr) { (void)gb;(void)err;(void)addr; }
+
+static void lcd_draw_line(struct gb_s* gb, const uint8_t* pixels, const uint_fast8_t line) {
+    AppCtx* ctx = (AppCtx*)gb->direct.priv;
+    if (!ctx || !ctx->fb_indexed) return;
+    if (line >= FRAME_H) return;
+    uint8_t* row = &ctx->fb_indexed[(line * FRAME_W) / 4];
+    for (int x=0;x<FRAME_W;x++) {
+        uint8_t shade = pixels[x] & 0x03;
+        int byte_idx = x >> 2;
+        int shift = 6 - ((x & 0x03) * 2);
+        row[byte_idx] = (uint8_t)((row[byte_idx] & ~(0x03 << shift)) | ((shade & 0x03) << shift));
+    }
+    ctx->lines_drawn++;
+}
+
+static void get_save_path(const char* rom_path, char* out, size_t out_len) {
+    if (!rom_path || !out) return;
+    strncpy(out, rom_path, out_len-1); out[out_len-1]='\0';
+    char* dot=strrchr(out,'.'); char* sl=strrchr(out,'/');
+    if (dot && (!sl || dot>sl)) { snprintf(dot, out_len-(dot-out), ".sav"); }
+    else { strncat(out,".sav",out_len-strlen(out)-1); }
+}
+static void load_cart_ram(AppCtx* ctx) {
+    if (!ctx || !ctx->rom_path[0]) return;
+    char save_path[MAX_PATH];
+    get_save_path(ctx->rom_path, save_path, sizeof(save_path));
+    size_t save_sz=0;
+    if (gb_get_save_size_s(&ctx->gb, &save_sz)!=0) save_sz=gb_get_save_size(&ctx->gb);
+    if (save_sz==0) return;
+    if (ctx->cart_ram) { heap_caps_free(ctx->cart_ram); ctx->cart_ram=NULL; }
+    ctx->cart_ram_size=save_sz;
+    ctx->cart_ram=alloc_psram(save_sz);
+    if (!ctx->cart_ram){ ctx->cart_ram_size=0; return; }
+    memset(ctx->cart_ram,0,save_sz);
+    FILE* f=fopen(save_path,"rb");
+    if (!f) return;
+    fread(ctx->cart_ram,1,save_sz,f); fclose(f);
+}
+static void save_cart_ram(AppCtx* ctx) {
+    if (!ctx || !ctx->cart_ram || ctx->cart_ram_size==0) return;
+    if (!ctx->rom_path[0]) return;
+    char save_path[MAX_PATH];
+    get_save_path(ctx->rom_path, save_path, sizeof(save_path));
+    FILE* f=fopen(save_path,"wb");
+    if (!f) return;
+    fwrite(ctx->cart_ram,1,ctx->cart_ram_size,f); fclose(f);
+}
+
+static bool load_rom_file(AppCtx* ctx, const char* path) {
+    if (!ctx || !path) return false;
+    FILE* f=fopen(path,"rb");
+    if (!f) return false;
+    fseek(f,0,SEEK_END); long sz=ftell(f); fseek(f,0,SEEK_SET);
+    if (sz<=0 || sz>MAX_ROM_SIZE){ fclose(f); return false; }
+    uint8_t* buf=alloc_psram((size_t)sz);
+    if (!buf){ fclose(f); return false; }
+    size_t read=fread(buf,1,(size_t)sz,f); fclose(f);
+    if (read!=(size_t)sz){ heap_caps_free(buf); return false; }
+
+    if (ctx->rom_data) { if (ctx->cart_ram) save_cart_ram(ctx); heap_caps_free(ctx->rom_data); }
+    if (ctx->cart_ram){ heap_caps_free(ctx->cart_ram); ctx->cart_ram=NULL; ctx->cart_ram_size=0; }
+
+    ctx->rom_data=buf; ctx->rom_size=(size_t)sz;
+    strncpy(ctx->rom_path,path,sizeof(ctx->rom_path)-1); ctx->rom_path[sizeof(ctx->rom_path)-1]='\0';
+    memset(&ctx->gb,0,sizeof(ctx->gb));
+    ctx->joypad_state=0xFF;
+    enum gb_init_error_e err=gb_init(&ctx->gb, gb_rom_read, gb_cart_ram_read, gb_cart_ram_write, gb_error_handler, ctx);
+    if (err!=GB_INIT_NO_ERROR){ heap_caps_free(ctx->rom_data); ctx->rom_data=NULL; ctx->rom_size=0; return false; }
+    gb_init_lcd(&ctx->gb, lcd_draw_line);
+    load_cart_ram(ctx);
+    gb_reset(&ctx->gb);
+    char title[32]={0}; gb_get_rom_name(&ctx->gb, title); strncpy(ctx->rom_title,title,sizeof(ctx->rom_title)-1);
+    ctx->rom_loaded=true;
+    return true;
+}
+static void scan_rom_dir(AppCtx* ctx) {
+    ctx->rom_count=0;
+    for (size_t d=0; d < sizeof(ROMS_CANDIDATE_DIRS)/sizeof(ROMS_CANDIDATE_DIRS[0]) && ctx->rom_count < MAX_ROMS; d++) {
+        const char* dir_path = ROMS_CANDIDATE_DIRS[d];
+        DIR* dir=opendir(dir_path);
+        if (!dir) continue;
+        struct dirent* ent;
+        while ((ent=readdir(dir))!=NULL && ctx->rom_count<MAX_ROMS){
+            if (ent->d_name[0]=='.') continue;
+            size_t len=strlen(ent->d_name);
+            if (len<3) continue;
+            bool is_gb = (strcasecmp(ent->d_name+len-3,".gb")==0) || (len>=4 && (strcasecmp(ent->d_name+len-4,".gbc")==0 || strcasecmp(ent->d_name+len-4,".sgb")==0 || strcasecmp(ent->d_name+len-4,".bin")==0));
+            if (!is_gb) continue;
+            char full[MAX_PATH];
+            snprintf(full,sizeof(full),"%s/%s",dir_path,ent->d_name);
+            bool dup=false;
+            for(int i=0;i<ctx->rom_count;i++){
+                if (strcasecmp(ctx->roms[i].filename, ent->d_name)==0) { dup=true; break; }
+            }
+            if (dup) continue;
+            RomEntry* e=&ctx->roms[ctx->rom_count++];
+            strncpy(e->filename, ent->d_name, sizeof(e->filename)-1); e->filename[sizeof(e->filename)-1]='\0';
+            strncpy(e->fullpath, full, sizeof(e->fullpath)-1); e->fullpath[sizeof(e->fullpath)-1]='\0';
+        }
+        closedir(dir);
+    }
+}
+
+static void emu_timer_cb(lv_timer_t* timer) {
+    AppCtx* ctx=(AppCtx*)lv_timer_get_user_data(timer);
+    if (!ctx || !ctx->emu_running || !ctx->rom_loaded || !ctx->canvas) return;
+    ctx->lines_drawn = 0;
+    ctx->gb.direct.joypad = ctx->joypad_state;
+    gb_run_frame(&ctx->gb);
+
+    if (ctx->lines_drawn == 0) {
+        static uint32_t tick=0; tick++;
+        for (int y=0;y<FRAME_H;y++) {
+            uint8_t* row=&ctx->fb_indexed[(y*FRAME_W)/4];
+            for (int x=0;x<FRAME_W;x++) {
+                int bi=x>>2; int sh=6-((x&3)*2);
+                uint8_t shade = (uint8_t)((x + y + tick) & 0x03);
+                row[bi] = (uint8_t)((row[bi] & ~(0x03<<sh)) | (shade<<sh));
+            }
+        }
+    }
+
+    if (ctx->fb_draw_buf) lv_image_cache_drop(ctx->fb_draw_buf);
+    lv_obj_invalidate(ctx->canvas);
+
+    ctx->fps_frames++;
+    int64_t now = esp_timer_get_time();
+    if (ctx->fps_last_us == 0) ctx->fps_last_us = now;
+    int64_t elapsed = now - ctx->fps_last_us;
+    if (elapsed >= 1000000) {
+        uint32_t fps = (uint32_t)((ctx->fps_frames * 1000000ULL) / (uint64_t)elapsed);
+        if (ctx->status_label) lv_label_set_text_fmt(ctx->status_label, "GB: %s  FPS:%lu L:%lu", ctx->rom_title[0] ? ctx->rom_title : "GameBoy", (unsigned long)fps, (unsigned long)ctx->lines_drawn);
+        printf("GAMEBOY_FPS %lu LINES %lu\n", (unsigned long)fps, (unsigned long)ctx->lines_drawn);
+        ctx->fps_frames = 0;
+        ctx->fps_last_us = now;
+    }
+}
+
+static void set_joypad_bit(AppCtx* ctx, uint8_t bit, bool pressed) {
+    if (!ctx) return;
+    if (pressed) ctx->joypad_state &= (uint8_t)~bit;
+    else ctx->joypad_state |= bit;
+}
+static void input_down_cb(lv_event_t* e){ BtnUserData* ud=(BtnUserData*)lv_event_get_user_data(e); if (!ud) return; set_joypad_bit(ud->ctx, ud->joypad_bit, true); }
+static void input_up_cb(lv_event_t* e){ BtnUserData* ud=(BtnUserData*)lv_event_get_user_data(e); if (!ud) return; set_joypad_bit(ud->ctx, ud->joypad_bit, false); }
+static void key_press_cb(lv_event_t* e){
+    AppCtx* ctx=(AppCtx*)lv_event_get_user_data(e);
+    uint32_t key=lv_event_get_key(e);
+    switch(key){
+        case LV_KEY_UP: set_joypad_bit(ctx, JOYPAD_UP, true); break;
+        case LV_KEY_DOWN: set_joypad_bit(ctx, JOYPAD_DOWN, true); break;
+        case LV_KEY_LEFT: set_joypad_bit(ctx, JOYPAD_LEFT, true); break;
+        case LV_KEY_RIGHT: set_joypad_bit(ctx, JOYPAD_RIGHT, true); break;
+        case LV_KEY_ENTER: set_joypad_bit(ctx, JOYPAD_START, true); break;
+        case LV_KEY_ESC: set_joypad_bit(ctx, JOYPAD_SELECT, true); break;
+        default: {
+            if (key== (uint32_t)'z' || key== (uint32_t)'Z') set_joypad_bit(ctx, JOYPAD_A, true);
+            else if (key== (uint32_t)'x' || key== (uint32_t)'X') set_joypad_bit(ctx, JOYPAD_B, true);
+            break;
+        }
+    }
+}
+
+static void build_browser_ui(AppCtx* ctx, lv_obj_t* parent);
+static void build_emu_ui(AppCtx* ctx, lv_obj_t* parent);
+static void switch_to_browser(AppCtx* ctx);
+static void switch_to_emu(AppCtx* ctx);
+
+static void rom_button_event(lv_event_t* e){
+    AppCtx* ctx=(AppCtx*)lv_event_get_user_data(e);
+    lv_obj_t* btn=lv_event_get_target_obj(e);
+    int* pIdx=(int*)lv_obj_get_user_data(btn);
+    if (!pIdx) return;
+    ctx->selected_rom_idx=*pIdx;
+    if (ctx->selected_rom_idx<0 || ctx->selected_rom_idx>=ctx->rom_count) return;
+    const char* path=ctx->roms[ctx->selected_rom_idx].fullpath;
+    if (load_rom_file(ctx, path)) switch_to_emu(ctx);
+    else if (ctx->status_label) lv_label_set_text_fmt(ctx->status_label, "Failed: %s", ctx->roms[ctx->selected_rom_idx].filename);
+}
+static void default_rom_event(lv_event_t* e){
+    AppCtx* ctx=(AppCtx*)lv_event_get_user_data(e);
+    if (load_rom_file(ctx, DEFAULT_ROM_PATH)) switch_to_emu(ctx);
+    else if (ctx->status_label) lv_label_set_text(ctx->status_label, "default.gb not found");
+}
+static void back_to_menu_event(lv_event_t* e){ AppCtx* ctx=(AppCtx*)lv_event_get_user_data(e); switch_to_browser(ctx); }
+
+static void build_browser_ui(AppCtx* ctx, lv_obj_t* parent){
+    lv_obj_clean(parent);
+    ctx->rom_list=NULL;
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_all(parent, 4, 0);
+    lv_obj_set_style_bg_color(parent, lv_color_black(), 0);
+    lv_obj_t* info=lv_label_create(parent);
+    lv_label_set_text_fmt(info, "GameBoy I2 fix – Place ROMs in Roms/GB – Found %d ROMs", ctx->rom_count);
+    lv_label_set_long_mode(info, LV_LABEL_LONG_WRAP);
+    lv_obj_set_width(info, LV_PCT(100));
+    lv_obj_set_style_text_color(info, lv_color_white(), 0);
+    ctx->status_label=lv_label_create(parent);
+    lv_label_set_text(ctx->status_label, "Select a ROM – tap .gb in Files app also works");
+    lv_obj_set_style_text_color(ctx->status_label, lv_palette_main(LV_PALETTE_ORANGE), 0);
+    lv_obj_t* list=lv_list_create(parent);
+    lv_obj_set_width(list, LV_PCT(100));
+    lv_obj_set_flex_grow(list, 1);
+    ctx->rom_list=list;
+    if (ctx->rom_count==0){
+        lv_obj_t* lbl=lv_label_create(parent);
+        lv_label_set_text(lbl, "No ROMs. Put .gb in /sdcard/Roms/GB");
+        lv_obj_set_style_text_color(lbl, lv_color_white(), 0);
+    } else {
+        for (int i=0;i<ctx->rom_count;i++){
+            lv_obj_t* btn=lv_list_add_btn(list, LV_SYMBOL_FILE, ctx->roms[i].filename);
+            int* idx=(int*)malloc(sizeof(int)); *idx=i;
+            lv_obj_set_user_data(btn, idx);
+            lv_obj_add_event_cb(btn, rom_button_event, LV_EVENT_CLICKED, ctx);
+        }
+    }
+    lv_obj_t* default_btn=lv_btn_create(parent);
+    lv_obj_set_width(default_btn, LV_PCT(100));
+    lv_obj_t* dlbl=lv_label_create(default_btn);
+    lv_label_set_text(dlbl, "Try default.gb");
+    lv_obj_center(dlbl);
+    lv_obj_add_event_cb(default_btn, default_rom_event, LV_EVENT_CLICKED, ctx);
+}
+
+static void build_emu_ui(AppCtx* ctx, lv_obj_t* parent){
+    lv_obj_clean(parent);
+    lv_obj_set_style_bg_color(parent, lv_color_black(), 0);
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_all(parent, 0, 0);
+    lv_obj_set_style_pad_row(parent, 0, 0);
+    lv_obj_remove_flag(parent, LV_OBJ_FLAG_SCROLLABLE);
+
+    lv_obj_t* info_bar=lv_obj_create(parent);
+    lv_obj_set_width(info_bar, LV_PCT(100));
+    lv_obj_set_height(info_bar, LV_SIZE_CONTENT);
+    lv_obj_set_style_pad_all(info_bar, 2, 0);
+    lv_obj_set_style_border_width(info_bar, 0, 0);
+    lv_obj_set_flex_flow(info_bar, LV_FLEX_FLOW_ROW);
+    lv_obj_set_style_bg_color(info_bar, lv_color_hex(0x222222), 0);
+
+    lv_obj_t* title_lbl=lv_label_create(info_bar);
+    ctx->status_label = title_lbl;
+    lv_label_set_text_fmt(title_lbl, "GB: %s  FPS:--", ctx->rom_title[0]?ctx->rom_title:"GameBoy");
+    lv_obj_set_style_text_color(title_lbl, lv_color_white(), 0);
+
+    lv_obj_t* spacer=lv_obj_create(info_bar);
+    lv_obj_set_style_bg_opa(spacer, LV_OPA_TRANSP,0);
+    lv_obj_set_style_border_width(spacer,0,0);
+    lv_obj_set_flex_grow(spacer,1);
+
+    lv_obj_t* back_btn=lv_btn_create(info_bar);
+    lv_obj_set_size(back_btn, 60, 28);
+    lv_obj_t* bl=lv_label_create(back_btn); lv_label_set_text(bl,"Menu"); lv_obj_center(bl);
+    lv_obj_add_event_cb(back_btn, back_to_menu_event, LV_EVENT_CLICKED, ctx);
+
+    lv_obj_t* canvas_cont=lv_obj_create(parent);
+    lv_obj_set_width(canvas_cont, LV_PCT(100));
+    lv_obj_set_flex_grow(canvas_cont,1);
+    lv_obj_set_style_bg_color(canvas_cont, lv_color_black(),0);
+    lv_obj_set_style_border_width(canvas_cont,0,0);
+    lv_obj_set_style_pad_all(canvas_cont,2,0);
+    lv_obj_set_flex_flow(canvas_cont, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(canvas_cont, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_remove_flag(canvas_cont, LV_OBJ_FLAG_SCROLLABLE);
+
+    if (!ctx->fb_indexed){
+        size_t fb_bytes = (FRAME_W * FRAME_H) / 4;
+        ctx->fb_indexed=(uint8_t*)alloc_internal(fb_bytes);
+        if (ctx->fb_indexed){ ctx->framebuffer_allocated=true; memset(ctx->fb_indexed,0,fb_bytes); }
+    }
+
+    if (ctx->fb_indexed){
+        lv_coord_t disp_w = lv_display_get_horizontal_resolution(NULL);
+        lv_coord_t disp_h = lv_display_get_vertical_resolution(NULL);
+        int avail_h = disp_h - 160;
+        int avail_w = disp_w - 8;
+        int scale = 1;
+        if (avail_w >= FRAME_W * 3 && avail_h >= FRAME_H * 3) scale = 3;
+        else if (avail_w >= FRAME_W * 2 && avail_h >= FRAME_H * 2) scale = 2;
+
+        ctx->canvas = lv_canvas_create(canvas_cont);
+        lv_canvas_set_buffer(ctx->canvas, ctx->fb_indexed, FRAME_W, FRAME_H, LV_COLOR_FORMAT_I2);
+        lv_color32_t c0 = { .red=0xFF, .green=0xFF, .blue=0xFF, .alpha=0xFF };
+        lv_color32_t c1 = { .red=0xAA, .green=0xAA, .blue=0xAA, .alpha=0xFF };
+        lv_color32_t c2 = { .red=0x55, .green=0x55, .blue=0x55, .alpha=0xFF };
+        lv_color32_t c3 = { .red=0x00, .green=0x00, .blue=0x00, .alpha=0xFF };
+        lv_canvas_set_palette(ctx->canvas, 0, c0);
+        lv_canvas_set_palette(ctx->canvas, 1, c1);
+        lv_canvas_set_palette(ctx->canvas, 2, c2);
+        lv_canvas_set_palette(ctx->canvas, 3, c3);
+        ctx->fb_draw_buf = lv_canvas_get_draw_buf(ctx->canvas);
+        if (ctx->fb_draw_buf) lv_image_cache_drop(ctx->fb_draw_buf);
+        if (scale > 1) {
+            lv_image_set_scale(ctx->canvas, (uint32_t)(256 * scale));
+            lv_image_set_pivot(ctx->canvas, FRAME_W / 2, FRAME_H / 2);
+        }
+        lv_obj_set_style_border_width(ctx->canvas, 1, 0);
+        lv_obj_set_style_border_color(ctx->canvas, lv_color_hex(0x00FF00), 0);
+        lv_obj_center(ctx->canvas);
+    } else {
+        lv_obj_t* err=lv_label_create(canvas_cont); lv_label_set_text(err,"FB alloc failed"); lv_obj_set_style_text_color(err, lv_color_white(),0);
+    }
+
+    lv_obj_t* ctrl=lv_obj_create(parent);
+    ctx->controls_cont=ctrl;
+    lv_obj_set_width(ctrl, LV_PCT(100));
+    lv_obj_set_height(ctrl, 110);
+    lv_obj_set_style_pad_all(ctrl,2,0);
+    lv_obj_set_style_bg_color(ctrl, lv_color_hex(0x111111),0);
+    lv_obj_set_style_border_width(ctrl,0,0);
+    lv_obj_set_flex_flow(ctrl, LV_FLEX_FLOW_ROW);
+    lv_obj_set_flex_align(ctrl, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+
+    static BtnUserData btn_ud[8];
+    static bool ud_init=false;
+    if (!ud_init){ memset(btn_ud,0,sizeof(btn_ud)); ud_init=true; }
+
+    lv_obj_t* dpad=lv_obj_create(ctrl);
+    lv_obj_set_size(dpad,96,96);
+    lv_obj_set_style_bg_opa(dpad,LV_OPA_TRANSP,0);
+    lv_obj_set_style_border_width(dpad,0,0);
+    lv_obj_set_style_pad_all(dpad,0,0);
+    lv_obj_t* up=lv_btn_create(dpad); lv_obj_set_size(up,32,32); lv_obj_set_pos(up,32,0);
+    lv_obj_t* left=lv_btn_create(dpad); lv_obj_set_size(left,32,32); lv_obj_set_pos(left,0,32);
+    lv_obj_t* right=lv_btn_create(dpad); lv_obj_set_size(right,32,32); lv_obj_set_pos(right,64,32);
+    lv_obj_t* down=lv_btn_create(dpad); lv_obj_set_size(down,32,32); lv_obj_set_pos(down,32,64);
+    lv_obj_t* lbl; lbl=lv_label_create(up); lv_label_set_text(lbl, LV_SYMBOL_UP); lv_obj_center(lbl);
+    lbl=lv_label_create(down); lv_label_set_text(lbl, LV_SYMBOL_DOWN); lv_obj_center(lbl);
+    lbl=lv_label_create(left); lv_label_set_text(lbl, LV_SYMBOL_LEFT); lv_obj_center(lbl);
+    lbl=lv_label_create(right); lv_label_set_text(lbl, LV_SYMBOL_RIGHT); lv_obj_center(lbl);
+    ctx->btn_up=up; ctx->btn_down=down; ctx->btn_left=left; ctx->btn_right=right;
+    btn_ud[0].ctx=ctx; btn_ud[0].joypad_bit=JOYPAD_UP;   lv_obj_add_event_cb(up, input_down_cb, LV_EVENT_PRESSED, &btn_ud[0]); lv_obj_add_event_cb(up, input_up_cb, LV_EVENT_RELEASED, &btn_ud[0]); lv_obj_add_event_cb(up, input_up_cb, LV_EVENT_PRESS_LOST, &btn_ud[0]);
+    btn_ud[1].ctx=ctx; btn_ud[1].joypad_bit=JOYPAD_DOWN; lv_obj_add_event_cb(down, input_down_cb, LV_EVENT_PRESSED, &btn_ud[1]); lv_obj_add_event_cb(down, input_up_cb, LV_EVENT_RELEASED, &btn_ud[1]); lv_obj_add_event_cb(down, input_up_cb, LV_EVENT_PRESS_LOST, &btn_ud[1]);
+    btn_ud[2].ctx=ctx; btn_ud[2].joypad_bit=JOYPAD_LEFT; lv_obj_add_event_cb(left, input_down_cb, LV_EVENT_PRESSED, &btn_ud[2]); lv_obj_add_event_cb(left, input_up_cb, LV_EVENT_RELEASED, &btn_ud[2]); lv_obj_add_event_cb(left, input_up_cb, LV_EVENT_PRESS_LOST, &btn_ud[2]);
+    btn_ud[3].ctx=ctx; btn_ud[3].joypad_bit=JOYPAD_RIGHT;lv_obj_add_event_cb(right, input_down_cb, LV_EVENT_PRESSED, &btn_ud[3]); lv_obj_add_event_cb(right, input_up_cb, LV_EVENT_RELEASED, &btn_ud[3]); lv_obj_add_event_cb(right, input_up_cb, LV_EVENT_PRESS_LOST, &btn_ud[3]);
+
+    lv_obj_t* center_col=lv_obj_create(ctrl);
+    lv_obj_set_size(center_col,64,96);
+    lv_obj_set_style_bg_opa(center_col,LV_OPA_TRANSP,0);
+    lv_obj_set_style_border_width(center_col,0,0);
+    lv_obj_set_flex_flow(center_col, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(center_col, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+    lv_obj_set_style_pad_row(center_col,4,0);
+    lv_obj_t* sel_btn=lv_btn_create(center_col); lv_obj_set_size(sel_btn,60,28); lbl=lv_label_create(sel_btn); lv_label_set_text(lbl,"Sel"); lv_obj_center(lbl);
+    lv_obj_t* sta_btn=lv_btn_create(center_col); lv_obj_set_size(sta_btn,60,28); lbl=lv_label_create(sta_btn); lv_label_set_text(lbl,"Sta"); lv_obj_center(lbl);
+    ctx->btn_select=sel_btn; ctx->btn_start=sta_btn;
+    btn_ud[4].ctx=ctx; btn_ud[4].joypad_bit=JOYPAD_SELECT; lv_obj_add_event_cb(sel_btn, input_down_cb, LV_EVENT_PRESSED, &btn_ud[4]); lv_obj_add_event_cb(sel_btn, input_up_cb, LV_EVENT_RELEASED, &btn_ud[4]); lv_obj_add_event_cb(sel_btn, input_up_cb, LV_EVENT_PRESS_LOST, &btn_ud[4]);
+    btn_ud[5].ctx=ctx; btn_ud[5].joypad_bit=JOYPAD_START;  lv_obj_add_event_cb(sta_btn, input_down_cb, LV_EVENT_PRESSED, &btn_ud[5]); lv_obj_add_event_cb(sta_btn, input_up_cb, LV_EVENT_RELEASED, &btn_ud[5]); lv_obj_add_event_cb(sta_btn, input_up_cb, LV_EVENT_PRESS_LOST, &btn_ud[5]);
+
+    lv_obj_t* ab=lv_obj_create(ctrl);
+    lv_obj_set_size(ab,96,96);
+    lv_obj_set_style_bg_opa(ab,LV_OPA_TRANSP,0);
+    lv_obj_set_style_border_width(ab,0,0);
+    lv_obj_set_style_pad_all(ab,0,0);
+    lv_obj_t* b_btn=lv_btn_create(ab); lv_obj_set_size(b_btn,40,40); lv_obj_set_pos(b_btn,0,24); lv_obj_set_style_radius(b_btn,20,0);
+    lv_obj_t* a_btn=lv_btn_create(ab); lv_obj_set_size(a_btn,40,40); lv_obj_set_pos(a_btn,48,8); lv_obj_set_style_radius(a_btn,20,0);
+    lbl=lv_label_create(b_btn); lv_label_set_text(lbl,"B"); lv_obj_center(lbl);
+    lbl=lv_label_create(a_btn); lv_label_set_text(lbl,"A"); lv_obj_center(lbl);
+    ctx->btn_a=a_btn; ctx->btn_b=b_btn;
+    btn_ud[6].ctx=ctx; btn_ud[6].joypad_bit=JOYPAD_B; lv_obj_add_event_cb(b_btn, input_down_cb, LV_EVENT_PRESSED, &btn_ud[6]); lv_obj_add_event_cb(b_btn, input_up_cb, LV_EVENT_RELEASED, &btn_ud[6]); lv_obj_add_event_cb(b_btn, input_up_cb, LV_EVENT_PRESS_LOST, &btn_ud[6]);
+    btn_ud[7].ctx=ctx; btn_ud[7].joypad_bit=JOYPAD_A; lv_obj_add_event_cb(a_btn, input_down_cb, LV_EVENT_PRESSED, &btn_ud[7]); lv_obj_add_event_cb(a_btn, input_up_cb, LV_EVENT_RELEASED, &btn_ud[7]); lv_obj_add_event_cb(a_btn, input_up_cb, LV_EVENT_PRESS_LOST, &btn_ud[7]);
+
+    lv_obj_add_event_cb(parent, key_press_cb, LV_EVENT_KEY, ctx);
+    if (tt_lvgl_hardware_keyboard_is_available()){
+        lv_group_t* g=lv_group_get_default();
+        if (g){ lv_group_add_obj(g, parent); lv_group_focus_obj(parent); lv_group_set_editing(g, true); }
+    }
+
+    if (ctx->emu_timer){ lv_timer_delete(ctx->emu_timer); ctx->emu_timer=NULL; }
+    ctx->fps_frames = 0;
+    ctx->fps_last_us = esp_timer_get_time();
+    ctx->lines_drawn = 0;
+    ctx->emu_timer=lv_timer_create(emu_timer_cb, TICK_MS, ctx);
+    ctx->emu_running=true;
+    ctx->mode=APP_MODE_EMU;
+}
+
+static void switch_to_browser(AppCtx* ctx){
+    if (ctx->emu_timer){ lv_timer_delete(ctx->emu_timer); ctx->emu_timer=NULL; }
+    ctx->emu_running=false;
+    save_cart_ram(ctx);
+    ctx->mode=APP_MODE_BROWSER;
+    if (!ctx->browser_wrapper || !lv_obj_is_valid(ctx->browser_wrapper)) return;
+    if (ctx->emu_wrapper) lv_obj_add_flag(ctx->emu_wrapper, LV_OBJ_FLAG_HIDDEN);
+    lv_obj_remove_flag(ctx->browser_wrapper, LV_OBJ_FLAG_HIDDEN);
+    scan_rom_dir(ctx);
+    build_browser_ui(ctx, ctx->browser_wrapper);
+}
+static void switch_to_emu(AppCtx* ctx){
+    if (!ctx->rom_loaded) return;
+    if (ctx->browser_wrapper) lv_obj_add_flag(ctx->browser_wrapper, LV_OBJ_FLAG_HIDDEN);
+    if (!ctx->emu_wrapper) return;
+    lv_obj_remove_flag(ctx->emu_wrapper, LV_OBJ_FLAG_HIDDEN);
+    build_emu_ui(ctx, ctx->emu_wrapper);
+}
+
+static void* create_data(void){
+    AppCtx* ctx=(AppCtx*)calloc(1,sizeof(AppCtx));
+    if (ctx){ ctx->joypad_state=0xFF; ctx->mode=APP_MODE_BROWSER; ctx->selected_rom_idx=-1; }
+    return ctx;
+}
+static void destroy_data(void* data){
+    AppCtx* ctx=(AppCtx*)data;
+    if (!ctx) return;
+    if (ctx->emu_timer) lv_timer_delete(ctx->emu_timer);
+    if (ctx->fb_indexed) heap_caps_free(ctx->fb_indexed);
+    if (ctx->rom_data) heap_caps_free(ctx->rom_data);
+    if (ctx->cart_ram) heap_caps_free(ctx->cart_ram);
+    free(ctx);
+}
+static void on_create(AppHandle app, void* data){ AppCtx* ctx=(AppCtx*)data; if (ctx) ctx->app_handle=app; }
+static void on_destroy(AppHandle app, void* data){ (void)app;(void)data; }
+static void on_show(AppHandle app, void* data, lv_obj_t* parent){
+    AppCtx* ctx=(AppCtx*)data; if (!ctx) return;
+    ctx->app_handle=app;
+    lv_obj_remove_flag(parent, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_style_pad_all(parent,0,0);
+    lv_obj_set_style_pad_row(parent,0,0);
+    lv_obj_set_style_bg_color(parent, lv_color_black(),0);
+    ctx->toolbar=tt_lvgl_toolbar_create_for_app(parent, app);
+    lv_obj_set_style_bg_color(ctx->toolbar, lv_color_hex(0x111111),0);
+
+    ctx->root_wrapper=lv_obj_create(parent);
+    lv_obj_set_width(ctx->root_wrapper, LV_PCT(100));
+    lv_obj_set_flex_grow(ctx->root_wrapper,1);
+    lv_obj_set_style_pad_all(ctx->root_wrapper,0,0);
+    lv_obj_set_style_border_width(ctx->root_wrapper,0,0);
+    lv_obj_set_style_bg_color(ctx->root_wrapper, lv_color_black(),0);
+    lv_obj_set_flex_flow(ctx->root_wrapper, LV_FLEX_FLOW_COLUMN);
+    lv_obj_remove_flag(ctx->root_wrapper, LV_OBJ_FLAG_SCROLLABLE);
+
+    ctx->browser_wrapper=lv_obj_create(ctx->root_wrapper);
+    lv_obj_set_width(ctx->browser_wrapper, LV_PCT(100));
+    lv_obj_set_flex_grow(ctx->browser_wrapper,1);
+    lv_obj_set_style_pad_all(ctx->browser_wrapper,0,0);
+    lv_obj_set_style_border_width(ctx->browser_wrapper,0,0);
+
+    ctx->emu_wrapper=lv_obj_create(ctx->root_wrapper);
+    lv_obj_set_width(ctx->emu_wrapper, LV_PCT(100));
+    lv_obj_set_flex_grow(ctx->emu_wrapper,1);
+    lv_obj_set_style_pad_all(ctx->emu_wrapper,0,0);
+    lv_obj_set_style_border_width(ctx->emu_wrapper,0,0);
+    lv_obj_add_flag(ctx->emu_wrapper, LV_OBJ_FLAG_HIDDEN);
+
+    BundleHandle bundle = tt_app_get_parameters(app);
+    char file_param[512] = {0};
+    bool hasFileParam = false;
+    const char* file_to_try = NULL;
+    if (bundle && tt_bundle_opt_string(bundle, "file", file_param, sizeof(file_param))) {
+        hasFileParam = file_param[0] != '\0';
+        file_to_try = file_param;
+    }
+
+    if (hasFileParam && file_to_try) {
+        char resolved[MAX_PATH];
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-truncation"
+        if (strncmp(file_to_try, "/sdcard", 7) == 0 || strncmp(file_to_try, "/data", 5) == 0) {
+            snprintf(resolved, sizeof(resolved), "%s", file_to_try);
+        } else if (file_to_try[0] == '/') {
+            snprintf(resolved, sizeof(resolved), "/sdcard%s", file_to_try);
+        } else {
+            char truncated_file[400];
+            snprintf(truncated_file, sizeof(truncated_file), "%s", file_to_try);
+            snprintf(resolved, sizeof(resolved), "/sdcard/%s", truncated_file);
+        }
+#pragma GCC diagnostic pop
+        struct stat st;
+        if (stat(resolved, &st)==0 && load_rom_file(ctx, resolved)) {
+            build_browser_ui(ctx, ctx->browser_wrapper);
+            switch_to_emu(ctx);
+            return;
+        }
+        if (load_rom_file(ctx, file_to_try)) {
+            build_browser_ui(ctx, ctx->browser_wrapper);
+            switch_to_emu(ctx);
+            return;
+        }
+    }
+
+    scan_rom_dir(ctx);
+    const char* default_candidates[] = { DEFAULT_ROM_PATH_1, DEFAULT_ROM_PATH_2, DEFAULT_ROM_PATH_3, DEFAULT_ROM_PATH_4, ROMS_DIR_LEGACY "/default.gb" };
+    for (size_t i=0;i<sizeof(default_candidates)/sizeof(default_candidates[0]);i++) {
+        struct stat st;
+        if (stat(default_candidates[i], &st)==0 && load_rom_file(ctx, default_candidates[i])) {
+            build_browser_ui(ctx, ctx->browser_wrapper);
+            switch_to_emu(ctx);
+            return;
+        }
+    }
+    build_browser_ui(ctx, ctx->browser_wrapper);
+    lv_obj_remove_flag(ctx->browser_wrapper, LV_OBJ_FLAG_HIDDEN);
+    ctx->mode=APP_MODE_BROWSER;
+}
+static void on_hide(AppHandle app, void* data){
+    (void)app;
+    AppCtx* ctx=(AppCtx*)data; if (!ctx) return;
+    if (ctx->emu_timer){ lv_timer_delete(ctx->emu_timer); ctx->emu_timer=NULL; }
+    ctx->emu_running=false;
+    if (ctx->rom_loaded) save_cart_ram(ctx);
+    ctx->canvas=NULL; ctx->fb_draw_buf=NULL; ctx->toolbar=NULL; ctx->root_wrapper=NULL; ctx->browser_wrapper=NULL; ctx->emu_wrapper=NULL;
+    ctx->status_label=NULL; ctx->rom_list=NULL; ctx->controls_cont=NULL;
+    ctx->btn_up=ctx->btn_down=ctx->btn_left=ctx->btn_right=NULL;
+    ctx->btn_a=ctx->btn_b=ctx->btn_start=ctx->btn_select=NULL;
+    ctx->app_handle=NULL;
+}
+
+int main(int argc, char* argv[]){
+    (void)argc; (void)argv;
+    tt_app_register((AppRegistration){
+        .createData=create_data,
+        .destroyData=destroy_data,
+        .onCreate=on_create,
+        .onDestroy=on_destroy,
+        .onShow=on_show,
+        .onHide=on_hide
+    });
+    return 0;
+}

Apps/GameBoy/manifest.properties

@@ -0,0 +1,11 @@
+[manifest]
+version=0.1
+[target]
+sdk=0.8.0-dev
+platforms=esp32,esp32s3,esp32c6,esp32p4
+[app]
+id=one.tactility.gameboy
+versionName=0.1.0-dev
+versionCode=1
+name=GameBoy
+description=DMG Game Boy emulator (no audio prototype, Peanut-GB)

Apps/RobotArm/CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.20)
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+
+if (DEFINED ENV{TACTILITY_SDK_PATH})
+    set(TACTILITY_SDK_PATH $ENV{TACTILITY_SDK_PATH})
+else()
+    set(TACTILITY_SDK_PATH "../../release/TactilitySDK")
+    message(WARNING "⚠️ TACTILITY_SDK_PATH environment variable is not set, defaulting to ${TACTILITY_SDK_PATH}")
+endif()
+
+include("${TACTILITY_SDK_PATH}/TactilitySDK.cmake")
+set(EXTRA_COMPONENT_DIRS ${TACTILITY_SDK_PATH})
+
+project(RobotArm)
+tactility_project(RobotArm)

Apps/RobotArm/main/CMakeLists.txt

@@ -0,0 +1,6 @@
+file(GLOB_RECURSE SOURCE_FILES Source/*.c)
+idf_component_register(
+    SRCS ${SOURCE_FILES}
+    REQUIRES TactilitySDK lwip
+)
+target_compile_options(${COMPONENT_LIB} PRIVATE -Wno-format-truncation -Wno-unused-but-set-variable -Wno-unused-function)

Apps/RobotArm/main/Source/main.c

@@ -0,0 +1,523 @@
+#include <tt_app.h>
+#include <tt_lvgl_toolbar.h>
+#include <tactility/lvgl_fonts.h>
+#include <tt_mdns.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <lwip/sockets.h>
+#include <lwip/inet.h>
+
+#define TAG "RobotArm"
+#define ARM_PORT 80
+#define ARM_PATH "/api/mcp"
+#define NUM_JOINTS 6
+#define SEQ_MAX 16
+
+typedef struct {
+    const char* name;
+    const char* cute;
+    uint32_t bg;
+    uint32_t accent;
+    int home, rmin, rmax;
+    int value, last_sent;
+} Joint;
+
+static Joint joints[NUM_JOINTS] = {
+    {"base","Base",0xFFD6E0,0xFF8FA8,70,0,180,70,-1},
+    {"shoulder","Shldr",0xD6E8FF,0x8FB6FF,40,0,70,40,-1},
+    {"elbow","Elbow",0xFFE8C5,0xFFB86A,20,0,120,20,-1},
+    {"pitch","Pitch",0xD5F0D5,0x88D488,90,30,150,90,-1},
+    {"roll","Roll",0xE8D5FF,0xB088FF,90,30,150,90,-1},
+    {"gripper","Grip",0xFFF0B3,0xFFD060,90,0,180,90,-1},
+};
+
+typedef struct { int v[NUM_JOINTS]; } Frame;
+static Frame seq[SEQ_MAX];
+static int seq_len = 0, seq_idx = -1;
+static bool seq_playing = false;
+static int seq_play_pos = 0;
+
+static char arm_host[64] = "";
+static bool arm_connected = false;
+
+typedef struct {
+    AppHandle app;
+    lv_obj_t* root;
+    lv_obj_t* content; // scrollable column container
+    lv_obj_t* status;
+    lv_obj_t* sliders[6];
+    lv_obj_t* vals[6];
+    lv_obj_t* seq_label;
+    lv_obj_t* play_label;
+    lv_obj_t* blocks[SEQ_MAX];
+    lv_obj_t* connect_box;
+    lv_obj_t* main_box;
+    lv_obj_t* connect_label;
+    lv_obj_t* connect_spinner;
+    int pend[6];
+    bool has[6];
+    int ticks[6];
+    lv_timer_t* poll;
+    lv_timer_t* seq_timer;
+    lv_timer_t* connect_timer;
+    int connect_attempts;
+} Ctx;
+static Ctx* g = NULL;
+
+static uint16_t my_htons(uint16_t v){ return (v<<8)|(v>>8); }
+
+static int http_post(const char* host,int port,const char* path,const char* body,char* out,size_t olen){
+    uint32_t ip=ipaddr_addr(host);
+    if(ip==0 || ip==0xFFFFFFFF) return -2;
+    int fd=lwip_socket(AF_INET,SOCK_STREAM,0);
+    if(fd<0) return -1;
+    struct sockaddr_in s; memset(&s,0,sizeof(s));
+    s.sin_family=AF_INET; s.sin_port=my_htons(port); s.sin_addr.s_addr=ip;
+    struct timeval tv={2,0};
+    lwip_setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv));
+    lwip_setsockopt(fd,SOL_SOCKET,SO_SNDTIMEO,&tv,sizeof(tv));
+    if(lwip_connect(fd,(struct sockaddr*)&s,sizeof(s))<0){close(fd);return -2;}
+    char hdr[256]; int bl=strlen(body);
+    int hl=snprintf(hdr,sizeof(hdr),"POST %s HTTP/1.1\r\nHost: %s:%d\r\nContent-Type: application/json\r\nContent-Length: %d\r\nConnection: close\r\n\r\n",path,host,port,bl);
+    if(lwip_send(fd,hdr,hl,0)<0){close(fd);return -3;}
+    if(lwip_send(fd,body,bl,0)<0){close(fd);return -3;}
+    int tot=0; while(tot<(int)olen-1){int r=lwip_recv(fd,out+tot,olen-1-tot,0); if(r<=0) break; tot+=r;}
+    out[tot]='\0'; close(fd);
+    char* bp=strstr(out,"\r\n\r\n"); if(bp){bp+=4; memmove(out,bp,strlen(bp)+1);}
+    return tot>0?0:-4;
+}
+
+static bool jget(const char* js,const char* key,int* out){
+    const char* p=strstr(js,key); if(!p) return false;
+    p+=strlen(key); while(*p && *p!=':'){p++; if(!*p) return false;} p++;
+    while(*p && (*p==' '||*p=='\t'||*p=='"'||*p=='\\')) p++;
+    int sign=1; if(*p=='-'){sign=-1;p++;}
+    float v=0,frac=0.1f; bool dot=false,got=false;
+    while(*p){
+        if(*p>='0'&&*p<='9'){got=true; if(!dot) v=v*10+(*p-'0'); else {v+=(*p-'0')*frac; frac*=0.1f;}}
+        else if(*p=='.'&&!dot) dot=true; else break; p++;
+    }
+    if(!got) return false;
+    *out=(int)(v*sign+0.5f); return true;
+}
+static bool parse_state(const char* r,int* b,int* s,int* e,int* p,int* ro,int* gr){
+    int v; bool ok=true;
+    if(jget(r,"base",&v)) *b=v; else ok=false;
+    if(jget(r,"shoulder",&v)) *s=v; else ok=false;
+    if(jget(r,"elbow",&v)) *e=v; else ok=false;
+    if(jget(r,"pitch",&v)) *p=v; else ok=false;
+    if(jget(r,"roll",&v)) *ro=v; else ok=false;
+    if(jget(r,"gripper",&v)) *gr=v; else ok=false;
+    return ok;
+}
+static bool rpc_get(int* b,int* s,int* e,int* p,int* ro,int* gr){
+    const char* body="{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{\"name\":\"get_arm_state\",\"arguments\":{}}}";
+    char resp[2048]; memset(resp,0,sizeof(resp));
+    if(http_post(arm_host,ARM_PORT,ARM_PATH,body,resp,sizeof(resp))!=0) return false;
+    return parse_state(resp,b,s,e,p,ro,gr);
+}
+static bool rpc_move(const char* j,int a){
+    char body[300]; snprintf(body,sizeof(body),
+        "{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"tools/call\",\"params\":{\"name\":\"move_joint\",\"arguments\":{\"joint\":\"%s\",\"angle\":%d,\"duration\":0.5}}}",j,a);
+    char r[1024]; memset(r,0,sizeof(r)); return http_post(arm_host,ARM_PORT,ARM_PATH,body,r,sizeof(r))==0;
+}
+static bool rpc_move_all(int b,int s,int e,int p,int ro,int gr,float dur){
+    char body[420]; snprintf(body,sizeof(body),
+        "{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"tools/call\",\"params\":{\"name\":\"move_all_joints\",\"arguments\":{\"base\":%d,\"shoulder\":%d,\"elbow\":%d,\"pitch\":%d,\"roll\":%d,\"gripper\":%d,\"duration\":%.1f}}}",
+        b,s,e,p,ro,gr,dur);
+    char r[1024]; memset(r,0,sizeof(r)); return http_post(arm_host,ARM_PORT,ARM_PATH,body,r,sizeof(r))==0;
+}
+static bool rpc_home(void){
+    const char* b="{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"tools/call\",\"params\":{\"name\":\"home_arm\",\"arguments\":{\"duration\":1.0}}}";
+    char r[512]; memset(r,0,sizeof(r)); return http_post(arm_host,ARM_PORT,ARM_PATH,b,r,sizeof(r))==0;
+}
+static void set_status(const char* t){ if(g&&g->status) lv_label_set_text(g->status,t); }
+static void apply_ui(void){
+    if(!g) return;
+    for(int i=0;i<NUM_JOINTS;i++){
+        if(g->sliders[i]) lv_slider_set_value(g->sliders[i],joints[i].value,LV_ANIM_OFF);
+        if(g->vals[i]){char buf[8]; snprintf(buf,sizeof(buf),"%d",joints[i].value); lv_label_set_text(g->vals[i],buf);}
+    }
+}
+static void refresh_arm(void){
+    set_status("Reading...");
+    int b,s,e,p,ro,gr;
+    if(rpc_get(&b,&s,&e,&p,&ro,&gr)){
+        joints[0].value=b; joints[1].value=s; joints[2].value=e;
+        joints[3].value=p; joints[4].value=ro; joints[5].value=gr;
+        for(int i=0;i<NUM_JOINTS;i++){joints[i].last_sent=joints[i].value; if(g){g->pend[i]=joints[i].value; g->has[i]=false; g->ticks[i]=0;}}
+        apply_ui();
+        char buf[32]; snprintf(buf,sizeof(buf),"B%d S%d E%d",b,s,e); set_status(buf);
+    } else set_status("No arm");
+}
+static void del_ref_cb(lv_timer_t* t){ lv_timer_delete(t); refresh_arm(); }
+static void init_cb(lv_timer_t* t){ lv_timer_delete(t); refresh_arm(); }
+static void poll_cb(lv_timer_t* t){
+    (void)t; if(!g || !arm_connected) return;
+    for(int i=0;i<NUM_JOINTS;i++){
+        if(!g->has[i]) continue;
+        g->ticks[i]++; if(g->ticks[i]<3) continue;
+        g->has[i]=false; g->ticks[i]=0;
+        int tgt=g->pend[i]; if(joints[i].last_sent==tgt) continue;
+        joints[i].last_sent=tgt; joints[i].value=tgt;
+        char buf[24]; snprintf(buf,sizeof(buf),"%s %d",joints[i].cute,tgt); set_status(buf);
+        bool ok=rpc_move(joints[i].name,tgt);
+        snprintf(buf,sizeof(buf),"%s %d %s",joints[i].cute,tgt,ok?"o":"x"); set_status(buf);
+        break;
+    }
+}
+static void slider_cb(lv_event_t* e){
+    int idx=(int)(intptr_t)lv_event_get_user_data(e);
+    int v=(int)lv_slider_get_value(lv_event_get_target(e));
+    joints[idx].value=v;
+    if(g){
+        if(g->vals[idx]){char b[8]; snprintf(b,sizeof(b),"%d",v); lv_label_set_text(g->vals[idx],b);}
+        g->pend[idx]=v; g->has[idx]=true; g->ticks[idx]=0;
+    }
+}
+static void update_seq_ui(void){
+    if(!g) return;
+    if(g->seq_label){
+        if(seq_len==0) lv_label_set_text(g->seq_label,"empty");
+        else {char b[16]; snprintf(b,sizeof(b),"%d/%d", (seq_idx>=0?seq_idx+1:seq_len), seq_len); lv_label_set_text(g->seq_label,b);}
+    }
+    for(int i=0;i<SEQ_MAX;i++){
+        if(!g->blocks[i]) continue;
+        if(i<seq_len){
+            lv_obj_set_style_bg_opa(g->blocks[i],LV_OPA_COVER,0);
+            if(i==seq_idx){
+                lv_obj_set_style_border_width(g->blocks[i],3,0);
+                lv_obj_set_style_border_color(g->blocks[i],lv_color_hex(0xFFFFFF),0);
+            } else {
+                lv_obj_set_style_border_width(g->blocks[i],2,0);
+                lv_obj_set_style_border_color(g->blocks[i],lv_color_hex(0x3A3A3A),0);
+            }
+        } else {
+            lv_obj_set_style_bg_opa(g->blocks[i],LV_OPA_30,0);
+            lv_obj_set_style_border_width(g->blocks[i],0,0);
+        }
+    }
+}
+static void load_frame(int fidx){
+    if(fidx<0||fidx>=seq_len) return;
+    for(int i=0;i<NUM_JOINTS;i++){joints[i].value=seq[fidx].v[i]; joints[i].last_sent=joints[i].value; if(g){g->pend[i]=joints[i].value; g->has[i]=false;}}
+    apply_ui(); seq_idx=fidx; update_seq_ui();
+    char b[20]; snprintf(b,sizeof(b),"Frame %d",fidx+1); set_status(b);
+}
+static void seq_add_cb(void){ if(seq_len>=SEQ_MAX){set_status("Full"); return;} for(int i=0;i<NUM_JOINTS;i++) seq[seq_len].v[i]=joints[i].value; seq_len++; seq_idx=seq_len-1; update_seq_ui(); char b[16]; snprintf(b,sizeof(b),"+ %d",seq_len); set_status(b); }
+static void seq_rem_cb(void){
+    if(seq_len==0||seq_idx<0){set_status("Nothing"); return;}
+    int rem=seq_idx; for(int f=rem;f<seq_len-1;f++) seq[f]=seq[f+1];
+    seq_len--; if(seq_len==0){seq_idx=-1; update_seq_ui(); set_status("- empty"); return;}
+    if(seq_idx>=seq_len) seq_idx=seq_len-1; load_frame(seq_idx);
+}
+static void seq_prev_cb(void){ if(seq_len==0) return; int n=(seq_idx<=0)?seq_len-1:seq_idx-1; load_frame(n); }
+static void seq_next_cb(void){ if(seq_len==0) return; int n=(seq_idx>=seq_len-1)?0:seq_idx+1; load_frame(n); }
+static void seq_timer_cb(lv_timer_t* t){
+    (void)t; if(!seq_playing||seq_len==0) return;
+    int f=seq_play_pos%seq_len; int* v=seq[f].v;
+    if(!rpc_move_all(v[0],v[1],v[2],v[3],v[4],v[5],0.8f)){
+        set_status("Seq fail"); seq_playing=false;
+        if(g&&g->play_label) lv_label_set_text(g->play_label,"Play"); return;
+    }
+    for(int i=0;i<NUM_JOINTS;i++){joints[i].value=v[i]; joints[i].last_sent=v[i]; if(g){g->pend[i]=v[i]; g->has[i]=false;}}
+    apply_ui(); seq_idx=f; update_seq_ui();
+    char b[20]; snprintf(b,sizeof(b),"Play %d/%d",f+1,seq_len); set_status(b);
+    seq_play_pos++; if(seq_play_pos>=seq_len) seq_play_pos=0;
+}
+static void seq_play_cb(lv_event_t* e){
+    (void)e; if(seq_len==0){set_status("No frames"); return;}
+    seq_playing=!seq_playing;
+    if(g&&g->play_label) lv_label_set_text(g->play_label, seq_playing?"Pause":"Play");
+    if(seq_playing){seq_play_pos=(seq_idx>=0?seq_idx:0); set_status("Playing");} else set_status("Paused");
+}
+static void seq_add_ev(lv_event_t* e){(void)e; seq_add_cb();}
+static void seq_rem_ev(lv_event_t* e){(void)e; seq_rem_cb();}
+static void seq_prev_ev(lv_event_t* e){(void)e; seq_prev_cb();}
+static void seq_next_ev(lv_event_t* e){(void)e; seq_next_cb();}
+static void block_click_cb(lv_event_t* e){int idx=(int)(intptr_t)lv_event_get_user_data(e); if(idx<0||idx>=seq_len) return; load_frame(idx);}
+static void home_cb(lv_event_t* e){(void)e; set_status("Homing..."); if(rpc_home()){lv_timer_create(del_ref_cb,1200,NULL); set_status("Homed :3");} else set_status("Fail");}
+static void read_cb(lv_event_t* e){(void)e; refresh_arm();}
+static void open_cb(lv_event_t* e){(void)e; joints[5].value=0; apply_ui(); rpc_move("gripper",0); set_status("Open");}
+static void close_cb(lv_event_t* e){(void)e; joints[5].value=180; apply_ui(); rpc_move("gripper",180); set_status("Close");}
+
+static bool try_host(const char* host){
+    char resp[1024]; memset(resp,0,sizeof(resp));
+    if(http_post(host,ARM_PORT,ARM_PATH,"{\"jsonrpc\":\"2.0\",\"id\":9,\"method\":\"tools/call\",\"params\":{\"name\":\"get_arm_state\",\"arguments\":{}}}",resp,sizeof(resp))==0){
+        if(strstr(resp,"base")){
+            strncpy(arm_host,host,sizeof(arm_host)-1);
+            return true;
+        }
+    }
+    return false;
+}
+static void show_main_ui(void){
+    if(!g) return;
+    arm_connected=true;
+    if(g->connect_box) lv_obj_add_flag(g->connect_box, LV_OBJ_FLAG_HIDDEN);
+    if(g->main_box) lv_obj_clear_flag(g->main_box, LV_OBJ_FLAG_HIDDEN);
+    if(g->connect_timer){ lv_timer_delete(g->connect_timer); g->connect_timer=NULL; }
+    if(!g->poll) g->poll=lv_timer_create(poll_cb,100,NULL);
+    if(!g->seq_timer) g->seq_timer=lv_timer_create(seq_timer_cb,1300,NULL);
+    lv_timer_create(init_cb,500,NULL);
+    char buf[48]; snprintf(buf,sizeof(buf),"Conn %s",arm_host); set_status(buf);
+}
+static void connect_timer_cb(lv_timer_t* t){
+    (void)t; if(!g || arm_connected) return;
+    g->connect_attempts++;
+    char lbl[64];
+    if(g->connect_attempts==1) snprintf(lbl,sizeof(lbl),"mDNS browsing _robotarm._tcp...");
+    else snprintf(lbl,sizeof(lbl),"Searching (%d)...",g->connect_attempts);
+    if(g->connect_label) lv_label_set_text(g->connect_label,lbl);
+
+    // ── 1) mDNS browse for _robotarm._tcp (preferred) ──
+    TtMdnsBrowseResult res; memset(&res,0,sizeof(res));
+    if(tt_mdns_browse("_robotarm","_tcp",2500,10,&res)){
+        for(int i=0;i<res.count;i++){
+            if(res.services[i].primaryAddress[0]){
+                if(try_host(res.services[i].primaryAddress)){
+                    show_main_ui(); return;
+                }
+            }
+        }
+    }
+    // ── 2) mDNS resolve robotarm.local hostname ──
+    char ipbuf[64]={0};
+    if(tt_mdns_resolve_hostname("robotarm.local",2000,ipbuf) || tt_mdns_resolve_hostname("robotarm",2000,ipbuf)){
+        if(try_host(ipbuf)){ show_main_ui(); return; }
+    }
+    // ── 3) fallback hardcoded (old behavior) ──
+    const char* fallbacks[]={"192.168.68.148","192.168.68.103","192.168.68.102"};
+    int idx = (g->connect_attempts-1) % (int)(sizeof(fallbacks)/sizeof(fallbacks[0]));
+    if(try_host(fallbacks[idx])){ show_main_ui(); return; }
+
+    if(g->connect_attempts>15){
+        if(g->connect_label) lv_label_set_text(g->connect_label,"No arm found.\nMake sure robotarm\nis powered & on WiFi.\nTap Retry.");
+    }
+}
+static void retry_cb(lv_event_t* e){(void)e; if(!g) return; g->connect_attempts=0; if(g->connect_label) lv_label_set_text(g->connect_label,"Retrying mDNS...");}
+
+static void onShow(AppHandle app,void* data,lv_obj_t* parent){
+    (void)data;
+    Ctx* c=calloc(1,sizeof(Ctx)); if(!c) return;
+    c->app=app; g=c;
+    for(int i=0;i<NUM_JOINTS;i++){joints[i].last_sent=-1; c->pend[i]=joints[i].value; c->has[i]=false;}
+    arm_host[0]='\0'; arm_connected=false; c->connect_attempts=0;
+
+    lv_obj_t* tb=tt_lvgl_toolbar_create_for_app(parent,app); lv_obj_align(tb,LV_ALIGN_TOP_MID,0,0);
+
+    // Root fills screen below toolbar - NOT scrollable itself, content will be
+    lv_obj_t* root=lv_obj_create(parent);
+    c->root=root;
+    lv_obj_set_size(root,LV_PCT(100),LV_PCT(100));
+    lv_obj_set_style_pad_all(root,2,0); lv_obj_set_style_pad_top(root,36,0);
+    lv_obj_set_style_border_width(root,0,0);
+    lv_obj_set_style_bg_color(root,lv_color_hex(0xFFF8F0),0);
+    lv_obj_set_style_bg_opa(root,LV_OPA_COVER,0);
+    lv_obj_clear_flag(root, LV_OBJ_FLAG_SCROLLABLE);
+
+    // ── connecting screen (initial visible) ──
+    c->connect_box=lv_obj_create(root);
+    lv_obj_set_size(c->connect_box,LV_PCT(100),LV_PCT(100));
+    lv_obj_set_pos(c->connect_box,0,0);
+    lv_obj_set_style_border_width(c->connect_box,0,0);
+    lv_obj_set_style_bg_opa(c->connect_box,LV_OPA_TRANSP,0);
+    lv_obj_set_style_pad_all(c->connect_box,4,0);
+    lv_obj_clear_flag(c->connect_box, LV_OBJ_FLAG_SCROLLABLE);
+
+    lv_obj_t* tl=lv_label_create(c->connect_box);
+    lv_label_set_text(tl,"Finding robotarm...");
+    lv_obj_set_style_text_font(tl,lvgl_get_text_font(FONT_SIZE_LARGE),0);
+    lv_obj_set_style_text_color(tl,lv_color_hex(0x3D2B5A),0);
+    lv_obj_set_pos(tl,4,4);
+
+    c->connect_label=lv_label_create(c->connect_box);
+    lv_label_set_text(c->connect_label,"mDNS: _robotarm._tcp / robotarm.local\nFallback: 192.168.68.148\n\nSearching...");
+    lv_obj_set_style_text_font(c->connect_label,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+    lv_obj_set_style_text_color(c->connect_label,lv_color_hex(0x6A5A7A),0);
+    lv_obj_set_pos(c->connect_label,4,28); lv_obj_set_width(c->connect_label,260);
+
+    c->connect_spinner=lv_spinner_create(c->connect_box);
+    lv_obj_set_size(c->connect_spinner,40,40);
+    lv_obj_set_pos(c->connect_spinner,120,110);
+
+    lv_obj_t* rb=lv_btn_create(c->connect_box);
+    lv_obj_set_size(rb,80,28); lv_obj_set_pos(rb,80,170);
+    lv_obj_set_style_bg_color(rb,lv_color_hex(0xC5F5C5),0); lv_obj_set_style_radius(rb,8,0);
+    lv_obj_t* rbl=lv_label_create(rb); lv_label_set_text(rbl,"Retry");
+    lv_obj_set_style_text_font(rbl,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+    lv_obj_set_style_text_color(rbl,lv_color_hex(0x2A2A5A),0); lv_obj_center(rbl);
+    lv_obj_add_event_cb(rb,retry_cb,LV_EVENT_CLICKED,NULL);
+
+    // ── main scrollable content (hidden until connected) ──
+    // content is the ONLY scrollable container - FIX overall app scroller lost
+    c->content=lv_obj_create(root);
+    lv_obj_set_size(c->content,LV_PCT(100),LV_PCT(100));
+    lv_obj_set_pos(c->content,0,0);
+    lv_obj_set_style_border_width(c->content,0,0);
+    lv_obj_set_style_bg_opa(c->content,LV_OPA_TRANSP,0);
+    lv_obj_set_style_pad_all(c->content,0,0);
+    lv_obj_set_flex_flow(c->content, LV_FLEX_FLOW_COLUMN);
+    lv_obj_add_flag(c->content, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_set_scrollbar_mode(c->content, LV_SCROLLBAR_MODE_AUTO);
+
+    c->main_box=lv_obj_create(c->content);
+    lv_obj_set_size(c->main_box,LV_PCT(100),LV_SIZE_CONTENT);
+    lv_obj_set_style_border_width(c->main_box,0,0);
+    lv_obj_set_style_bg_opa(c->main_box,LV_OPA_TRANSP,0);
+    lv_obj_set_style_pad_all(c->main_box,0,0);
+    lv_obj_clear_flag(c->main_box, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_add_flag(c->main_box, LV_OBJ_FLAG_HIDDEN);
+
+    lv_obj_t* hdr=lv_obj_create(c->main_box); lv_obj_set_size(hdr,LV_PCT(100),16);
+    lv_obj_set_style_border_width(hdr,0,0); lv_obj_set_style_bg_opa(hdr,LV_OPA_TRANSP,0);
+    lv_obj_set_style_pad_all(hdr,0,0);
+    lv_obj_clear_flag(hdr, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_t* title=lv_label_create(hdr); lv_label_set_text(title,"Robot Arm :3");
+    lv_obj_set_style_text_font(title,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+    lv_obj_set_style_text_color(title,lv_color_hex(0x3D2B5A),0);
+    lv_obj_set_pos(title,2,0);
+    c->status=lv_label_create(hdr); lv_label_set_text(c->status,"Conn...");
+    lv_obj_set_style_text_font(c->status,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+    lv_obj_set_style_text_color(c->status,lv_color_hex(0xA08090),0);
+    lv_obj_set_pos(c->status,90,0);
+
+    lv_obj_t* brow=lv_obj_create(c->main_box); lv_obj_set_size(brow,LV_PCT(100),20);
+    lv_obj_set_style_border_width(brow,0,0); lv_obj_set_style_bg_opa(brow,LV_OPA_TRANSP,0);
+    lv_obj_set_style_pad_all(brow,0,0);
+    lv_obj_clear_flag(brow, LV_OBJ_FLAG_SCROLLABLE);
+    struct { const char* t; uint32_t col; lv_event_cb_t cb; } btns[]={
+        {"Home",0xFFD6E0,home_cb},{"Read",0xD6E8FF,read_cb},{"Open",0xD5F0D5,open_cb},{"Close",0xFFE8C5,close_cb},};
+    for(int i=0;i<4;i++){
+        lv_obj_t* b=lv_btn_create(brow); lv_obj_set_size(b,56,18);
+        lv_obj_set_style_bg_color(b,lv_color_hex(btns[i].col),0); lv_obj_set_style_radius(b,8,0);
+        lv_obj_set_pos(b,i*62+2,0);
+        lv_obj_t* l=lv_label_create(b); lv_label_set_text(l,btns[i].t);
+        lv_obj_set_style_text_font(l,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+        lv_obj_set_style_text_color(l,lv_color_hex(0x4A356A),0); lv_obj_center(l);
+        lv_obj_add_event_cb(b,btns[i].cb,LV_EVENT_CLICKED,NULL);
+    }
+
+    lv_obj_t* grid=lv_obj_create(c->main_box);
+    lv_obj_set_size(grid,LV_PCT(100),196);
+    lv_obj_set_style_border_width(grid,0,0); lv_obj_set_style_bg_opa(grid,LV_OPA_TRANSP,0);
+    lv_obj_set_style_pad_all(grid,2,0);
+    lv_obj_clear_flag(grid, LV_OBJ_FLAG_SCROLLABLE);
+    lv_obj_set_scrollbar_mode(grid, LV_SCROLLBAR_MODE_OFF);
+
+    for(int i=0;i<NUM_JOINTS;i++){
+        int col=i%3, row=i/3;
+        lv_obj_t* card=lv_obj_create(grid);
+        lv_obj_set_size(card,102,96);
+        lv_obj_set_pos(card,col*104+2,row*98);
+        lv_obj_set_style_bg_color(card,lv_color_hex(joints[i].bg),0);
+        lv_obj_set_style_bg_opa(card,LV_OPA_90,0);
+        lv_obj_set_style_radius(card,12,0);
+        lv_obj_set_style_border_width(card,0,0);
+        lv_obj_set_style_pad_all(card,3,0);
+        lv_obj_clear_flag(card, LV_OBJ_FLAG_SCROLLABLE);
+        lv_obj_set_scrollbar_mode(card, LV_SCROLLBAR_MODE_OFF);
+
+        lv_obj_t* name=lv_label_create(card);
+        lv_label_set_text(name,joints[i].cute);
+        lv_obj_set_style_text_font(name,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+        lv_obj_set_style_text_color(name,lv_color_hex(0x4A356A),0); lv_obj_set_pos(name,2,0);
+
+        c->vals[i]=lv_label_create(card);
+        char vb[8]; snprintf(vb,sizeof(vb),"%d",joints[i].value);
+        lv_label_set_text(c->vals[i],vb);
+        lv_obj_set_style_text_font(c->vals[i],lvgl_get_text_font(FONT_SIZE_SMALL),0);
+        lv_obj_set_style_text_color(c->vals[i],lv_color_hex(0xC04060),0); lv_obj_set_pos(c->vals[i],40,0);
+
+        lv_obj_t* rlbl=lv_label_create(card);
+        char rb[12]; snprintf(rb,sizeof(rb),"%d-%d",joints[i].rmin,joints[i].rmax);
+        lv_label_set_text(rlbl,rb);
+        lv_obj_set_style_text_font(rlbl,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+        lv_obj_set_style_text_color(rlbl,lv_color_hex(0xA090A0),0); lv_obj_set_pos(rlbl,58,0);
+
+        lv_obj_t* sl=lv_slider_create(card);
+        c->sliders[i]=sl;
+        lv_obj_set_size(sl,22,72);
+        lv_obj_set_pos(sl,40,20);
+        lv_slider_set_range(sl,joints[i].rmin,joints[i].rmax);
+        lv_slider_set_value(sl,joints[i].value,LV_ANIM_OFF);
+        lv_obj_set_style_bg_color(sl,lv_color_hex(0xFFFFFF),LV_PART_MAIN);
+        lv_obj_set_style_bg_opa(sl,LV_OPA_80,LV_PART_MAIN);
+        lv_obj_set_style_radius(sl,10,LV_PART_MAIN);
+        lv_obj_set_style_bg_color(sl,lv_color_hex(joints[i].accent),LV_PART_INDICATOR);
+        lv_obj_set_style_radius(sl,10,LV_PART_INDICATOR);
+        lv_obj_set_style_bg_color(sl,lv_color_hex(0xFFFFFF),LV_PART_KNOB);
+        lv_obj_set_style_border_color(sl,lv_color_hex(joints[i].accent),LV_PART_KNOB);
+        lv_obj_set_style_border_width(sl,2,LV_PART_KNOB);
+        lv_obj_set_style_radius(sl,12,LV_PART_KNOB);
+        lv_obj_set_style_pad_all(sl,3,LV_PART_KNOB);
+        lv_obj_add_event_cb(sl,slider_cb,LV_EVENT_VALUE_CHANGED,(void*)(intptr_t)i);
+    }
+
+    lv_obj_t* seqbar=lv_obj_create(c->main_box);
+    lv_obj_set_size(seqbar,316,96);
+    lv_obj_set_style_bg_color(seqbar,lv_color_hex(0xF0E8FF),0);
+    lv_obj_set_style_bg_opa(seqbar,LV_OPA_90,0);
+    lv_obj_set_style_radius(seqbar,12,0);
+    lv_obj_set_style_border_width(seqbar,1,0);
+    lv_obj_set_style_border_color(seqbar,lv_color_hex(0xD0C0E0),0);
+    lv_obj_set_style_pad_all(seqbar,4,0);
+    lv_obj_clear_flag(seqbar, LV_OBJ_FLAG_SCROLLABLE);
+
+    lv_obj_t* seq_t=lv_label_create(seqbar); lv_label_set_text(seq_t,"Seq");
+    lv_obj_set_style_text_font(seq_t,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+    lv_obj_set_style_text_color(seq_t,lv_color_hex(0x3D2B5A),0); lv_obj_set_pos(seq_t,2,0);
+    c->seq_label=lv_label_create(seqbar); lv_label_set_text(c->seq_label,"empty");
+    lv_obj_set_style_text_font(c->seq_label,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+    lv_obj_set_style_text_color(c->seq_label,lv_color_hex(0x6A5A7A),0); lv_obj_set_pos(c->seq_label,30,0);
+    struct { const char* t; uint32_t col; lv_event_cb_t cb; int play; } sbtns[]={
+        {"-",0xFFB7B7,seq_rem_ev,0},{"<",0xD6E8FF,seq_prev_ev,0},
+        {"Play",0xC5F5C5,seq_play_cb,1},{">",0xD6E8FF,seq_next_ev,0},{"+",0xFFE8A0,seq_add_ev,0},};
+    for(int i=0;i<5;i++){
+        lv_obj_t* b=lv_btn_create(seqbar);
+        lv_obj_set_size(b,(i==2)?56:38,32);
+        lv_obj_set_style_bg_color(b,lv_color_hex(sbtns[i].col),0);
+        lv_obj_set_style_radius(b,8,0);
+        int xs[5]={64,110,158,220,260};
+        lv_obj_set_pos(b,xs[i],0);
+        lv_obj_t* l=lv_label_create(b); if(sbtns[i].play) c->play_label=l;
+        lv_label_set_text(l,sbtns[i].t);
+        lv_obj_set_style_text_font(l,lvgl_get_text_font(FONT_SIZE_SMALL),0);
+        lv_obj_set_style_text_color(l,lv_color_hex(0x2A2A5A),0); lv_obj_center(l);
+        lv_obj_add_event_cb(b,sbtns[i].cb,LV_EVENT_CLICKED,NULL);
+    }
+    uint32_t blk_cols[16]={
+        0xFF8FA8,0x8FB6FF,0xFFB86A,0x88D488,0xB088FF,0xFFD060,0xFF7AA2,0x7AC8FF,
+        0xFDBA74,0x86EFAC,0xA78BFA,0xFDE68A,0xFCA5A5,0x93C5FD,0xBEF264,0xFDA4AF
+    };
+    for(int i=0;i<SEQ_MAX;i++){
+        lv_obj_t* blk=lv_btn_create(seqbar);
+        lv_obj_set_size(blk,22,22);
+        lv_obj_set_pos(blk,(i%8)*24+2,(i/8)*24+38);
+        lv_obj_set_style_bg_color(blk,lv_color_hex(blk_cols[i]),0);
+        lv_obj_set_style_radius(blk,6,0);
+        lv_obj_set_style_border_width(blk,0,0);
+        lv_obj_set_style_bg_opa(blk,LV_OPA_30,0);
+        c->blocks[i]=blk;
+        lv_obj_add_event_cb(blk,block_click_cb,LV_EVENT_CLICKED,(void*)(intptr_t)i);
+    }
+    update_seq_ui();
+
+    c->connect_timer=lv_timer_create(connect_timer_cb, 1000, NULL);
+    connect_timer_cb(NULL);
+}
+
+static void onHide(AppHandle app,void* data){
+    (void)app;(void)data;
+    if(g){
+        if(g->poll) lv_timer_delete(g->poll);
+        if(g->seq_timer) lv_timer_delete(g->seq_timer);
+        if(g->connect_timer) lv_timer_delete(g->connect_timer);
+        free(g); g=NULL;
+    }
+    seq_playing=false; arm_connected=false;
+}
+int main(int argc,char* argv[]){(void)argc;(void)argv; tt_app_register((AppRegistration){.onShow=onShow,.onHide=onHide}); return 0;}

Apps/RobotArm/manifest.properties

@@ -0,0 +1,13 @@
+[manifest]
+version=0.1
+
+[target]
+sdk=0.8.0-dev
+platforms=esp32s3
+
+[app]
+id=one.tactility.robotarm
+versionName=0.1.0
+versionCode=1
+name=Robot Arm
+description=Cute controller for MCP robot arm

Libraries/PeanutGB/README.md

@@ -0,0 +1,23 @@
+# Peanut-GB vendored library
+
+Source: https://github.com/deltabeard/Peanut-GB
+File: peanut_gb.h (single-header emulator)
+License: MIT License - Copyright (c) 2018-2023 Mahyar Koshkouei
+Date Vendored: 2026-07-17 UTC
+Upstream: master branch latest as fetched 2026-07-17
+Commit URL: https://github.com/deltabeard/Peanut-GB/tree/master
+Size: ~4044 lines
+
+MIT license text is preserved intact at top of peanut_gb.h header.
+SameBoy-derived portions: Copyright (c) 2015-2019 Lior Halphon, also MIT.
+
+Usage:
+```c
+#define ENABLE_SOUND 0
+#define ENABLE_LCD 1
+#include "peanut_gb.h"
+```
+
+No modifications applied — used as-is.
+
+For Tactility GameBoy app, audio is disabled (ENABLE_SOUND 0) per prototype spec.