diff --git a/internal_filesystem/apps/cz.ucw.pavel.columns/META-INF/MANIFEST.JSON b/internal_filesystem/apps/cz.ucw.pavel.columns/META-INF/MANIFEST.JSON
new file mode 100644
index 00000000..51d15601
--- /dev/null
+++ b/internal_filesystem/apps/cz.ucw.pavel.columns/META-INF/MANIFEST.JSON
@@ -0,0 +1,25 @@
+{
+"name": "Columns",
+"publisher": "Pavel Machek",
+"short_description": "Falling columns game",
+"long_description": "Blocks of 3 colors are falling. Align the colors to make blocks di\
+sappear.",
+"icon_url": "https://apps.micropythonos.com/apps/cz.ucw.pavel.columns/icons/cz.ucw.pavel.columns_0.0.1_64x64.png",
+"download_url": "https://apps.micropythonos.com/apps/cz.ucw.pavel.columns/mpks/cz.ucw.pavel.columns_0.0.1.mpk",
+"fullname": "cz.ucw.pavel.columns",
+"version": "0.0.1",
+"category": "utilities",
+"activities": [
+    {
+      "entrypoint": "assets/main.py",
+      "classname": "Main",
+      "intent_filters": [
+        {
+          "action": "main",
+          "category": "launcher"
+        }
+      ]
+    }
+  ]
+}
+
diff --git a/internal_filesystem/apps/cz.ucw.pavel.columns/assets/main.py b/internal_filesystem/apps/cz.ucw.pavel.columns/assets/main.py
new file mode 100644
index 00000000..4bbc58b5
--- /dev/null
+++ b/internal_filesystem/apps/cz.ucw.pavel.columns/assets/main.py
@@ -0,0 +1,337 @@
+import time
+import random
+
+"""
+Columns -- falling columns game
+
+Possible TODOs:
+
+should blink explosions
+explodes while moving?
+/ in bottom left part may not explode
+
+smooth moving?
+music?
+some kind of game over?
+
+more contrast colors?
+different shapes?
+
+"""
+
+from mpos import Activity
+
+try:
+    import lvgl as lv
+except ImportError:
+    pass
+
+class Main(Activity):
+
+    COLS = 6
+    ROWS = 12
+
+    COLORS = [
+        0xE74C3C,  # red
+        0xF1C40F,  # yellow
+        0x2ECC71,  # green
+        0x3498DB,  # blue
+        0x9B59B6,  # purple
+    ]
+
+    EMPTY = -1
+
+    FALL_INTERVAL = 1000  # ms
+    # I can do 120 in this config :-).
+
+    def __init__(self):
+        super().__init__()
+        self.board = [[self.EMPTY for _ in range(self.COLS)] for _ in range(self.ROWS)]
+        self.cells = []
+
+        self.active_col = self.COLS // 2
+        self.active_row = -3
+        self.active_colors = []
+
+        self.timer = None
+        self.animating = False
+
+    # ---------------------------------------------------------------------
+
+    def onCreate(self):
+        self.screen = lv.obj()
+        self.screen.remove_flag(lv.obj.FLAG.SCROLLABLE)
+
+        vert = 60
+        horiz = 60
+        font = lv.font_montserrat_20
+
+        score = lv.label(self.screen)
+        score.align(lv.ALIGN.TOP_LEFT, 5, 25)
+        score.set_text("Score")
+        score.set_style_text_font(font, 0)
+        self.lb_score = score
+
+        btn_left = lv.button(self.screen)
+        btn_left.set_size(horiz, vert)
+        btn_left.align(lv.ALIGN.BOTTOM_LEFT, 5, -10-vert)
+        btn_left.add_event_cb(lambda e: self.move(-1), lv.EVENT.CLICKED, None)
+        lc = lv.label(btn_left)
+        lc.set_style_text_font(font, 0)
+        lc.set_text("<")
+        lc.center()
+
+        btn_right = lv.button(self.screen)
+        btn_right.set_size(horiz, vert)
+        btn_right.align(lv.ALIGN.BOTTOM_RIGHT, -5, -10-vert)
+        btn_right.add_event_cb(lambda e: self.move(1), lv.EVENT.CLICKED, None)
+        lc = lv.label(btn_right)
+        lc.set_style_text_font(font, 0)
+        lc.set_text(">")
+        lc.center()
+
+        btn_rotate = lv.button(self.screen)
+        btn_rotate.set_size(horiz, vert)
+        btn_rotate.align(lv.ALIGN.BOTTOM_RIGHT, -5, -15-vert-vert)
+        btn_rotate.add_event_cb(lambda e: self.rotate(), lv.EVENT.CLICKED, None)
+        lc = lv.label(btn_rotate)
+        lc.set_style_text_font(font, 0)
+        lc.set_text("R")
+        lc.center()
+
+        btn_down = lv.button(self.screen)
+        btn_down.set_size(horiz, vert)
+        btn_down.align(lv.ALIGN.BOTTOM_LEFT, 5, -5)
+        btn_down.add_event_cb(lambda e: self.tick(0), lv.EVENT.CLICKED, None)
+        lc = lv.label(btn_down)
+        lc.set_style_text_font(font, 0)
+        lc.set_text("v")
+        lc.center()
+        
+        d = lv.display_get_default()
+        self.SCREEN_WIDTH = d.get_horizontal_resolution()
+        self.SCREEN_HEIGHT = d.get_vertical_resolution()
+
+        self.CELL = min(
+            self.SCREEN_WIDTH // (self.COLS + 1),
+            self.SCREEN_HEIGHT // (self.ROWS + 1)
+        )
+
+        board_x = (self.SCREEN_WIDTH - self.CELL * self.COLS) // 2
+        board_y = (self.SCREEN_HEIGHT - self.CELL * self.ROWS) // 2
+
+        for r in range(self.ROWS):
+            row = []
+            for c in range(self.COLS):
+                o = lv.obj(self.screen)
+                o.set_size(self.CELL - 2, self.CELL - 2)
+                o.set_pos(
+                    board_x + c * self.CELL + 1,
+                    board_y + r * self.CELL + 1
+                )
+                o.set_style_radius(4, 0)
+                o.set_style_bg_color(lv.color_hex(0x1C2833), 0)
+                o.set_style_border_width(1, 0)
+                row.append(o)
+            self.cells.append(row)
+
+        # Make screen focusable for keyboard input
+        focusgroup = lv.group_get_default()
+        if focusgroup:
+            focusgroup.add_obj(self.screen)
+
+        #self.screen.add_event_cb(self.on_touch, lv.EVENT.CLICKED, None)
+        self.screen.add_event_cb(self.on_key, lv.EVENT.KEY, None)
+        
+        self.setContentView(self.screen)
+
+        self.new_game()
+        self.spawn_piece()
+        
+
+    def new_game(self):
+        self.score = 0
+    # ---------------------------------------------------------------------
+
+    def onResume(self, screen):
+        self.timer = lv.timer_create(self.tick, self.FALL_INTERVAL, None)
+
+    def onPause(self, screen):
+        if self.timer:
+            self.timer.delete()
+            self.timer = None
+
+    # ---------------------------------------------------------------------
+
+    def spawn_piece(self):
+        self.active_col = self.COLS // 2
+        self.active_row = -3
+        self.active_colors = [random.randrange(len(self.COLORS)) for _ in range(3)]
+
+    def tick(self, t):
+        if self.can_fall():
+            self.active_row += 1
+        else:
+            self.lock_piece()
+            self.clear_matches()
+            self.spawn_piece()
+
+        self.redraw()
+
+    # ---------------------------------------------------------------------
+
+    def can_fall(self):
+        for i in range(3):
+            r = self.active_row + i + 1
+            c = self.active_col
+            if r >= self.ROWS:
+                return False
+            if r >= 0 and self.board[r][c] != self.EMPTY:
+                return False
+        return True
+
+    def lock_piece(self):
+        for i in range(3):
+            r = self.active_row + i
+            if r >= 0:
+                self.board[r][self.active_col] = self.active_colors[i]
+
+    # ---------------------------------------------------------------------
+
+    def clear_matches(self):
+        to_clear = set()
+        score = 0
+
+        for r in range(self.ROWS):
+            for c in range(self.COLS):
+                color = self.board[r][c]
+                if color == self.EMPTY:
+                    continue
+
+                # horizontal
+                if c <= self.COLS - 3:
+                    if all(self.board[r][c + i] == color for i in range(3)):
+                        for i in range(3):
+                            to_clear.add((r, c + i))
+                            score += 1
+
+                # vertical
+                if r <= self.ROWS - 3:
+                    if all(self.board[r + i][c] == color for i in range(3)):
+                        for i in range(3):
+                            to_clear.add((r + i, c))
+                            score += 1
+
+                # diagonal \
+                if r <= self.ROWS - 3 and c <= self.COLS - 3:
+                    if all(self.board[r + i][c + i] == color for i in range(3)):
+                        for i in range(3):
+                            to_clear.add((r + i, c + i))
+                            score += 1
+
+                # diagonal /
+                if r <= self.ROWS - 3 and c > 2:
+                    if all(self.board[r + i][c - i] == color for i in range(3)):
+                        for i in range(3):
+                            to_clear.add((r + i, c - i))
+                            score += 1
+                            
+        if not to_clear:
+            return
+
+        print("Score: ", score)
+        self.score += score
+        self.lb_score.set_text("Score\n%d" % self.score)
+        for r, c in to_clear:
+            self.board[r][c] = self.EMPTY
+
+        self.redraw()
+        time.sleep(.5)
+        self.apply_gravity()
+        self.redraw()
+        time.sleep(.5)
+        self.clear_matches()
+        self.redraw()
+
+    def apply_gravity(self):
+        for c in range(self.COLS):
+            stack = [self.board[r][c] for r in range(self.ROWS) if self.board[r][c] != self.EMPTY]
+            for r in range(self.ROWS):
+                self.board[r][c] = self.EMPTY
+            for i, v in enumerate(reversed(stack)):
+                self.board[self.ROWS - 1 - i][c] = v
+
+    # ---------------------------------------------------------------------
+
+    def redraw(self):
+        # draw board
+        for r in range(self.ROWS):
+            for c in range(self.COLS):
+                v = self.board[r][c]
+                if v == self.EMPTY:
+                    self.cells[r][c].set_style_bg_color(lv.color_hex(0x1C2833), 0)
+                else:
+                    self.cells[r][c].set_style_bg_color(
+                        lv.color_hex(self.COLORS[v]), 0
+                    )
+
+        # draw active piece
+        for i in range(3):
+            r = self.active_row + i
+            if r >= 0 and r < self.ROWS:
+                self.cells[r][self.active_col].set_style_bg_color(
+                    lv.color_hex(self.COLORS[self.active_colors[i]]), 0
+                )
+
+    # ---------------------------------------------------------------------
+
+    def on_touch(self, e):
+        return
+        print("Touch event")
+        p = lv.indev_get_act().get_point()
+        x = p.x
+
+        if x < self.SCREEN_WIDTH // 3:
+            self.move(-1)
+        elif x > self.SCREEN_WIDTH * 2 // 3:
+            self.move(1)
+        else:
+            self.rotate()
+
+    def on_key(self, event):
+        """Handle keyboard input"""
+        print("Keyboard event")
+        key = event.get_key()
+        if key == ord("a"):
+            self.move(-1)
+            return
+        if key == ord("w"):
+            self.rotate()
+            return
+        if key == ord("d"):
+            self.move(1)
+            return
+        if key == ord("s"):
+            self.tick(0)
+            return
+        
+        #if key == lv.KEY.ENTER or key == lv.KEY.UP or key == ord("A") or key == ord("a"):
+        print(f"on_key: unhandled key {key}")
+
+    def move(self, dx):
+        nc = self.active_col + dx
+        if not(0 <= nc < self.COLS):
+            return
+        
+        for i in range(3):
+            r = self.active_row + i
+            if self.board[r][nc] != self.EMPTY:
+                return
+            
+        self.active_col = nc
+        self.redraw()
+
+    def rotate(self):
+        self.active_colors = self.active_colors[-1:] + self.active_colors[:-1]
+        self.redraw()
+
diff --git a/internal_filesystem/apps/cz.ucw.pavel.columns/res/mipmap-mdpi/icon_64x64.png b/internal_filesystem/apps/cz.ucw.pavel.columns/res/mipmap-mdpi/icon_64x64.png
new file mode 100644
index 00000000..49812a67
Binary files /dev/null and b/internal_filesystem/apps/cz.ucw.pavel.columns/res/mipmap-mdpi/icon_64x64.png differ
diff --git a/internal_filesystem/apps/cz.ucw.pavel.compass/META-INF/MANIFEST.JSON b/internal_filesystem/apps/cz.ucw.pavel.compass/META-INF/MANIFEST.JSON
new file mode 100644
index 00000000..dd52c192
--- /dev/null
+++ b/internal_filesystem/apps/cz.ucw.pavel.compass/META-INF/MANIFEST.JSON
@@ -0,0 +1,24 @@
+{
+"name": "Compass",
+"publisher": "Pavel Machek",
+"short_description": "Application for testing accelerometer and magnetometer",
+"long_description": "Simple compass application, allowing tests of accelerometer and magnetometer.",
+"icon_url": "https://apps.micropythonos.com/apps/cz.ucw.pavel.compass/icons/cz.ucw.pavel.compass_0.0.1_64x64.png",
+"download_url": "https://apps.micropythonos.com/apps/cz.ucw.pavel.compass/mpks/cz.ucw.pavel.compass_0.0.1.mpk",
+"fullname": "cz.ucw.pavel.compass",
+"version": "0.0.1",
+"category": "utilities",
+"activities": [
+    {
+      "entrypoint": "assets/main.py",
+      "classname": "Main",
+      "intent_filters": [
+        {
+          "action": "main",
+          "category": "launcher"
+        }
+      ]
+    }
+  ]
+}
+
diff --git a/internal_filesystem/apps/cz.ucw.pavel.compass/assets/main.py b/internal_filesystem/apps/cz.ucw.pavel.compass/assets/main.py
new file mode 100644
index 00000000..383da538
--- /dev/null
+++ b/internal_filesystem/apps/cz.ucw.pavel.compass/assets/main.py
@@ -0,0 +1,687 @@
+"""
+Robot translated that from bwatch/magcali.js
+
+"""
+
+import time
+import os
+import math
+
+try:
+    import lvgl as lv
+except ImportError:
+    pass
+
+from mpos import Activity, MposKeyboard, SensorManager
+
+# -----------------------------
+# Utilities
+# -----------------------------
+
+def clamp(v, lo, hi):
+    if v < lo:
+        return lo
+    if v > hi:
+        return hi
+    return v
+
+def to_rad(deg):
+    return deg * math.pi / 180.0
+
+def to_deg(rad):
+    return rad * 180.0 / math.pi
+
+# -----------------------------
+# Calibration + heading
+# -----------------------------
+
+class Compass:
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.vmin = [10000.0, 10000.0, 10000.0]
+        self.vmax = [-10000.0, -10000.0, -10000.0]
+
+    def step(self, v):
+        """
+        Update min/max. Returns True if calibration box changed ("bad" in JS).
+        """
+        bad = False
+        for i in range(3):
+            if v[i] < self.vmin[i]:
+                self.vmin[i] = v[i]
+                bad = True
+            if v[i] > self.vmax[i]:
+                self.vmax[i] = v[i]
+                bad = True
+        return bad
+
+    def compensated(self, v):
+        """
+        Returns:
+          vh = v - center
+          sc = scaled to [-1..+1]
+        """
+        vh = [0.0, 0.0, 0.0]
+        sc = [0.0, 0.0, 0.0]
+
+        for i in range(3):
+            center = (self.vmin[i] + self.vmax[i]) / 2.0
+            vh[i] = v[i] - center
+
+            denom = (self.vmax[i] - self.vmin[i])
+            if denom == 0:
+                sc[i] = 0.0
+            else:
+                sc[i] = (v[i] - self.vmin[i]) / denom * 2.0 - 1.0
+
+        return vh, sc
+
+    def heading_flat(self):
+        """
+        Equivalent of:
+          heading = atan2(sc[1], sc[0]) * 180/pi - 90
+
+        Compute heading based on last update(). This will only work well
+        on flat surface.
+        """
+        vh, sc = self.compensated(self.val)
+        
+        h = to_deg(math.atan2(sc[1], sc[0])) - 90.0
+        while h < 0:
+            h += 360.0
+        while h >= 360.0:
+            h -= 360.0
+        return h
+
+
+class TiltCompass(Compass):
+    def __init__(self):
+        super().__init__()
+
+    def tilt_calibrate(self):
+        """
+        JS tiltCalibrate(min,max)
+        vmin/vmax are dicts with x,y,z
+        """
+        vmin = self.vmin
+        vmax = self.vmax
+        
+        offset = ( (vmax[0] + vmin[0]) / 2.0,
+                   (vmax[1] + vmin[1]) / 2.0,
+                   (vmax[2] + vmin[2]) / 2.0 )
+        delta = ( (vmax[0] - vmin[0]) / 2.0,
+                  (vmax[1] - vmin[1]) / 2.0,
+                  (vmax[2] - vmin[2]) / 2.0 )
+
+        avg = (delta[0] + delta[1] + delta[2]) / 3.0
+
+        # Avoid division by zero
+        scale = (
+            avg / delta[0] if delta[0] else 1.0,
+            avg / delta[1] if delta[1] else 1.0,
+            avg / delta[2] if delta[2] else 1.0,
+        )
+
+        self.offset = offset
+        self.scale = scale
+
+    def heading_tilted(self):
+        """
+        Returns heading 0..360
+        """
+        mag_xyz = self.val
+        acc_xyz = self.acc
+        
+        if mag_xyz is None or acc_xyz is None:
+            return None
+
+        self.tilt_calibrate()
+
+        mx, my, mz = mag_xyz
+        ax, ay, az = acc_xyz
+
+        dx = (mx - self.offset[0]) * self.scale[0]
+        dy = (my - self.offset[1]) * self.scale[1]
+        dz = (mz - self.offset[2]) * self.scale[2]
+
+        # JS:
+        # phi = atan(-g.x/-g.z)
+        # theta = atan(-g.y/(-g.x*sinphi-g.z*cosphi))
+        # ...
+        # psi = atan2(yh,xh)
+        #
+        # Keep the same structure.
+
+        # Avoid pathological az=0
+        if az == 0:
+            az = 1e-9
+
+        phi = math.atan((-ax) / (-az))
+        cosphi = math.cos(phi)
+        sinphi = math.sin(phi)
+
+        denom = (-ax * sinphi - az * cosphi)
+        if denom == 0:
+            denom = 1e-9
+
+        theta = math.atan((-ay) / denom)
+        costheta = math.cos(theta)
+        sintheta = math.sin(theta)
+
+        xh = dy * costheta + dx * sinphi * sintheta + dz * cosphi * sintheta
+        yh = dz * sinphi - dx * cosphi
+
+        psi = to_deg(math.atan2(yh, xh))
+        if psi < 0:
+            psi += 360.0
+        return psi
+
+# -----------------------------
+# Canvas (LVGL)
+# -----------------------------
+
+class Canvas:
+    """
+    LVGL canvas + layer drawing Canvas.
+
+    This matches ports where:
+      - lv.canvas has init_layer() / finish_layer()
+      - primitives are drawn via lv.draw_* into lv.layer_t
+    """
+
+    def __init__(self, scr, canvas):
+        self.scr = scr
+
+        # Screen size
+        self.W = scr.get_width()
+        self.H = scr.get_height()
+
+        # Bottom button bar
+        self.margin = 2
+        self.bar_h = 39
+
+        # Canvas drawing area (everything above button bar)
+        self.draw_w = self.W
+        self.draw_h = self.H - (self.bar_h + self.margin * 2)
+
+        self.canvas = canvas
+
+        # Background: white (change if you want dark theme)
+        self.canvas.set_style_bg_color(lv.color_white(), lv.PART.MAIN)
+
+        # Buffer: your working example uses 4 bytes/pixel
+        # Reality filter: this depends on LV_COLOR_DEPTH; but your example proves it works.
+        self.buf = bytearray(self.draw_w * self.draw_h * 4)
+        self.canvas.set_buffer(self.buf, self.draw_w, self.draw_h, lv.COLOR_FORMAT.NATIVE)
+
+        # Layer used for draw engine
+        self.layer = lv.layer_t()
+        self.canvas.init_layer(self.layer)
+
+        # Persistent draw descriptors (avoid allocations)
+        self._line_dsc = lv.draw_line_dsc_t()
+        lv.draw_line_dsc_t.init(self._line_dsc)
+        self._line_dsc.width = 1
+        self._line_dsc.color = lv.color_black()
+        self._line_dsc.round_end = 1
+        self._line_dsc.round_start = 1
+
+        self._label_dsc = lv.draw_label_dsc_t()
+        lv.draw_label_dsc_t.init(self._label_dsc)
+        self._label_dsc.color = lv.color_black()
+        self._label_dsc.font = lv.font_montserrat_24
+
+        self._rect_dsc = lv.draw_rect_dsc_t()
+        lv.draw_rect_dsc_t.init(self._rect_dsc)
+        self._rect_dsc.bg_opa = lv.OPA.TRANSP
+        self._rect_dsc.border_opa = lv.OPA.COVER
+        self._rect_dsc.border_width = 1
+        self._rect_dsc.border_color = lv.color_black()
+
+        self._fill_dsc = lv.draw_rect_dsc_t()
+        lv.draw_rect_dsc_t.init(self._fill_dsc)
+        self._fill_dsc.bg_opa = lv.OPA.COVER
+        self._fill_dsc.bg_color = lv.color_black()
+        self._fill_dsc.border_width = 1
+
+        # Clear once
+        self.clear()
+
+    # ----------------------------
+    # Layer lifecycle
+    # ----------------------------
+
+    def _begin(self):
+        # Start drawing into the layer
+        self.canvas.init_layer(self.layer)
+
+    def _end(self):
+        # Commit drawing
+        self.canvas.finish_layer(self.layer)
+
+    # ----------------------------
+    # Public API: drawing
+    # ----------------------------
+
+    def clear(self):
+        # Clear the canvas background
+        self.canvas.fill_bg(lv.color_white(), lv.OPA.COVER)
+
+    def text(self, x, y, s, fg = lv.color_black()):
+        self._begin()
+
+        dsc = lv.draw_label_dsc_t()
+        lv.draw_label_dsc_t.init(dsc)
+        dsc.text = str(s)
+        dsc.font = lv.font_montserrat_24
+        dsc.color = lv.color_black()
+
+        area = lv.area_t()
+        area.x1 = x
+        area.y1 = y
+        area.x2 = x + self.W
+        area.y2 = y + self.H
+
+        lv.draw_label(self.layer, dsc, area)
+
+        self._end()
+
+    def line(self, x1, y1, x2, y2, fg = lv.color_black()):
+        self._begin()
+
+        dsc = self._line_dsc
+        dsc.p1 = lv.point_precise_t()
+        dsc.p2 = lv.point_precise_t()
+        dsc.p1.x = int(x1)
+        dsc.p1.y = int(y1)
+        dsc.p2.x = int(x2)
+        dsc.p2.y = int(y2)
+
+        lv.draw_line(self.layer, dsc)
+
+        self._end()
+
+    def circle(self, x, y, r, fg = lv.color_black()):
+        # Rounded rectangle trick (works everywhere)
+        self._begin()
+
+        a = lv.area_t()
+        a.x1 = int(x - r)
+        a.y1 = int(y - r)
+        a.x2 = int(x + r)
+        a.y2 = int(y + r)
+
+        dsc = self._rect_dsc
+        dsc.radius = lv.RADIUS_CIRCLE
+        dsc.border_color = fg
+
+        lv.draw_rect(self.layer, dsc, a)
+
+        self._end()
+
+    def fill_circle(self, x, y, r, fg = lv.color_black(), bg = lv.color_white()):
+        self._begin()
+
+        a = lv.area_t()
+        a.x1 = int(x - r)
+        a.y1 = int(y - r)
+        a.x2 = int(x + r)
+        a.y2 = int(y + r)
+
+        dsc = self._rect_dsc
+        dsc.radius = lv.RADIUS_CIRCLE
+        dsc.border_color = fg
+        dsc.bg_color = bg
+
+        lv.draw_rect(self.layer, dsc, a)
+
+        self._end()
+
+    def fill_rect(self, x, y, sx, sy, fg = lv.color_black(), bg = lv.color_white()):
+        self._begin()
+
+        a = lv.area_t()
+        a.x1 = x
+        a.y1 = y
+        a.x2 = x+sx
+        a.y2 = y+sy
+
+        dsc = self._fill_dsc
+        dsc.border_color = fg
+        dsc.bg_color = bg
+
+        lv.draw_rect(self.layer, dsc, a)
+
+        self._end()
+
+    def update(self):
+        # Nothing needed; drawing is committed per primitive.
+        # If you want, you can change the implementation so that:
+        # - draw ops happen between clear() and update()
+        # But then you must ensure the app calls update() once per frame.
+        pass
+
+# ----------------------------
+# App logic
+# ----------------------------
+
+class PagedCanvas(Activity):
+    def __init__(self):
+        super().__init__()
+        self.page = 0
+        self.pages = 3
+
+    def onCreate(self):
+        self.scr = lv.obj()
+        scr = self.scr
+
+        # Screen size
+        self.W = scr.get_width()
+        self.H = scr.get_height()
+
+        # Bottom button bar
+        self.margin = 2
+        self.bar_h = 39
+
+        # Canvas drawing area (everything above button bar)
+        self.draw_w = self.W
+        self.draw_h = self.H - (self.bar_h + self.margin * 2)
+
+        # Canvas
+        self.canvas = lv.canvas(self.scr)
+        self.canvas.set_size(self.draw_w, self.draw_h)
+        self.canvas.align(lv.ALIGN.TOP_LEFT, 0, 0)
+        self.canvas.set_style_border_width(0, 0)
+        
+        self.c = Canvas(self.scr, self.canvas)
+        
+        # Build buttons
+        self.build_buttons()
+        self.setContentView(self.c.scr)
+
+    # ----------------------------
+    # Button bar
+    # ----------------------------
+
+    def _make_btn(self, parent, x, y, w, h, label):
+        b = lv.button(parent)
+        b.set_pos(x, y)
+        b.set_size(w, h)
+
+        l = lv.label(b)
+        l.set_text(label)
+        l.center()
+
+        return b
+
+    def _btn_cb(self, evt, tag):
+        self.page = tag
+
+    def template_buttons(self, names):
+        margin = self.margin
+        y = self.H - self.bar_h - margin
+
+        num = len(names)
+        if num == 0:
+            self.buttons = []
+            return
+
+        w = (self.W - margin * (num + 1)) // num
+        h = self.bar_h
+        x0 = margin
+
+        self.buttons = []
+
+        for i, label in enumerate(names):
+            x = x0 + (w + margin) * i
+            btn = self._make_btn(self.scr, x, y, w, h, label)
+
+            # capture index correctly
+            btn.add_event_cb(
+                lambda evt, idx=i: self._btn_cb(evt, idx),
+                lv.EVENT.CLICKED,
+                None
+            )
+
+            self.buttons.append(btn)
+
+    def build_buttons(self):
+        self.template_buttons(["Pg0", "Pg1", "Pg2", "Pg3", "..."])
+
+    def onResume(self, screen):
+        self.timer = lv.timer_create(self.tick, 1000, None)
+
+    def onPause(self, screen):
+        if self.timer:
+            self.timer.delete()
+            self.timer = None
+            
+    def tick(self, t):
+        self.update()
+        self.draw()
+
+    def update(self):
+        pass
+
+    def draw_page_example(self):
+        ui = self.c
+        ui.clear()
+
+        st = 28
+        y = 2*st
+        ui.text(0, y, "Hello world, page is %d" % self.page)
+        y += st
+
+    def draw(self):
+        self.draw_page_example()
+
+    def handle_buttons(self):
+        ui = self.c
+
+# ----------------------------
+# App logic
+# ----------------------------
+
+class UCompass(TiltCompass):
+    # val (+vfirst, vmin, vmax) -- vector from magnetometer
+    # acc -- vector from accelerometer
+
+    # FIXME: we need to scale acc to similar values we used on watch;
+    # 90 degrees should correspond to outer circle
+
+    def __init__(self):
+        super().__init__()
+
+        self.accel = SensorManager.get_default_sensor(SensorManager.TYPE_ACCELEROMETER)
+        self.magn = SensorManager.get_default_sensor(SensorManager.TYPE_MAGNETIC_FIELD)
+
+        self.val = None
+        self.vfirst = None
+
+    def update(self):
+        v = SensorManager.read_sensor_once(self.magn)
+        sc = 1000
+        v = [float(v[1]) * sc, -float(v[0]) * sc, float(v[2]) * sc]
+        self.val = v
+
+        if self.vfirst is None:
+            self.vfirst = self.val[:]
+
+        acc = SensorManager.read_sensor_once(self.accel)
+        acc = ( -acc[1], -acc[0], acc[2] )
+        self.acc = acc
+
+class Main(PagedCanvas):
+    def __init__(self):
+        super().__init__()
+
+        self.cal = UCompass()
+
+        self.bad = False
+
+        self.heading = 0.0
+        self.heading2 = None
+
+        self.Ypos = 40
+        self.brg = None  # bearing target, degrees or None
+
+    def draw(self):
+        pass
+
+    def onResume(self, screen):
+        self.timer = lv.timer_create(self.tick, 50, None)
+
+    def update(self):
+        self.c.clear()
+        st = 14
+        y = 2*st
+
+        self.cal.update()
+        if self.cal.val is None:
+            self.c.text(0, y, f"No compass data")
+            y += st
+            return
+
+        self.bad = self.cal.step(self.cal.val)
+        self.heading = self.cal.heading_flat()
+
+        acc = self.cal.acc
+
+        #self.c.text(0, y, f"Compass, raw is {self.cal.val}, bad is {self.bad}, acc is {acc}")
+        y += st
+
+        self.heading2 = self.cal.heading_tilted()
+
+        if self.page == 0:
+            self.draw_top(acc)
+        elif self.page == 1:
+            self.draw_values()
+        elif self.page == 2:
+            self.c.text(0, y, f"Resetting calibration")
+            self.page = 0
+            self.cal.reset()
+
+    def build_buttons(self):
+        self.template_buttons(["Graph", "Values", "Reset"])
+
+    def draw_values(self):
+        self.c.text(0, 28, f"""
+Acccelerometer
+X {self.cal.acc[0]:.2f} Y {self.cal.acc[1]:.2f} Z {self.cal.acc[2]:.2f}
+Magnetometer      
+X {self.cal.val[0]:.2f} Y {self.cal.val[1]:.2f} Z {self.cal.val[2]:.2f}
+""")
+
+    def _px_per_deg(self):
+        # JS used deg->px: (deg/90)*(width/2.1)
+        s = min(self.c.W, self.c.H)
+        return (s / 2.1) / 90.0
+
+    def _degrees_to_pixels(self, deg):
+        return deg * self._px_per_deg()
+
+    # ---- TOP VIEW ----
+
+    def draw_top(self, acc):
+        heading=self.heading
+        heading2=self.heading2
+        vmin=self.cal.vmin
+        vmax=self.cal.vmax
+        vfirst=self.cal.vfirst
+        v=self.cal.val
+        bad=self.bad
+
+        cx = self.c.W // 2
+        cy = self.c.H // 2
+
+        # Crosshair
+        self.c.line(0, cy, self.c.W, cy)
+        self.c.line(cx, 0, cx, self.c.H)
+
+        # Circles (30/60/90 deg)
+        for rdeg in (30, 60, 90):
+            r = int(self._degrees_to_pixels(rdeg))
+            self.c.circle(cx, cy, r)
+
+        # Calibration box + current point
+        self._draw_calib_box(vmin, vmax, vfirst, v, bad)
+
+        # Accel circle
+        if acc is not None:
+            self._draw_accel(acc)
+
+        # Heading arrow(s)
+        self._draw_heading_arrow(heading, color=lv.color_make(255, 0, 0))
+        self.c.text(265, 22, "%d°" % int(heading))
+        if heading2 is not None:
+            self._draw_heading_arrow(heading2, color=lv.color_make(255, 255, 255), size = 100)
+            self.c.text(10, 22, "%d°" % int(heading2))
+
+    def _draw_heading_arrow(self, heading, color, size = 80):
+        cx = self.c.W / 2.0
+        cy = self.c.H / 2.0
+
+        rad = -to_rad(heading)
+        x2 = cx + math.sin(rad - 0.1) * size
+        y2 = cy - math.cos(rad - 0.1) * size
+        x3 = cx + math.sin(rad + 0.1) * size
+        y3 = cy - math.cos(rad + 0.1) * size
+
+        poly = [
+            int(cx), int(cy),
+            int(x2), int(y2),
+            int(x3), int(y3),
+        ]
+
+        self.c.line(poly[0], poly[1], poly[2], poly[3])
+        self.c.line(poly[2], poly[3], poly[4], poly[5])
+        self.c.line(poly[4], poly[5], poly[0], poly[1])
+
+    def _draw_accel(self, acc):
+        ax, ay, az = acc
+        cx = self.c.W / 2.0
+        cy = self.c.H / 2.0
+
+        x2 = cx + ax * self.c.W
+        y2 = cy + ay * self.c.W
+
+        self.c.circle(int(x2), int(y2), int(self.c.W / 8))
+
+    def _draw_calib_box(self, vmin, vmax, vfirst, v, bad):
+        if v is None or vfirst is None:
+            return
+
+        scale = 0.15
+
+        boxW = (vmax[0] - vmin[0]) * scale
+        boxH = -(vmax[1] - vmin[1]) * scale
+        boxX = (vmin[0] - vfirst[0]) * scale + self.c.W / 2.0
+        boxY = -(vmin[1] - vfirst[1]) * scale + self.c.H / 2.0
+
+        x = (v[0] - vfirst[0]) * scale + self.c.W / 2.0
+        y = -(v[1] - vfirst[1]) * scale + self.c.H / 2.0
+
+        # box rect
+        if bad:
+            bg = lv.color_make(255, 0, 0)
+        else:
+            bg = lv.color_make(0, 150, 0)
+
+        x1 = int(boxX)
+        y1 = int(boxY)
+        x2 = int(boxX + boxW)
+        y2 = int(boxY + boxH)
+
+        # normalize coords
+        xa = min(x1, x2)
+        xb = max(x1, x2)
+        ya = min(y1, y2)
+        yb = max(y1, y2)
+
+        self.c.fill_rect(xa, ya, xb - xa, yb - ya, bg = bg)
+
+        # point
+        self.c.fill_circle(int(x), int(y), 3, bg = lv.color_make(255, 255, 0))
+
diff --git a/internal_filesystem/apps/cz.ucw.pavel.compass/res/mipmap-mdpi/icon_64x64.png b/internal_filesystem/apps/cz.ucw.pavel.compass/res/mipmap-mdpi/icon_64x64.png
new file mode 100644
index 00000000..2b1f919f
Binary files /dev/null and b/internal_filesystem/apps/cz.ucw.pavel.compass/res/mipmap-mdpi/icon_64x64.png differ
diff --git a/internal_filesystem/apps/cz.ucw.pavel.weather/META-INF/MANIFEST.JSON b/internal_filesystem/apps/cz.ucw.pavel.weather/META-INF/MANIFEST.JSON
new file mode 100644
index 00000000..53b80338
--- /dev/null
+++ b/internal_filesystem/apps/cz.ucw.pavel.weather/META-INF/MANIFEST.JSON
@@ -0,0 +1,24 @@
+{
+"name": "Weather",
+"publisher": "Pavel Machek",
+"short_description": "Display weather information.",
+"long_description": "This displays weather information from open-meteo.com.",
+"icon_url": "https://apps.micropythonos.com/apps/cz.ucw.pavel.weather/icons/cz.ucw.pavel.weather_0.0.1_64x64.png",
+"download_url": "https://apps.micropythonos.com/apps/cz.ucw.pavel.weather/mpks/cz.ucw.pavel.weather_0.0.1.mpk",
+"fullname": "cz.ucw.pavel.weather",
+"version": "0.0.1",
+"category": "utilities",
+"activities": [
+    {
+      "entrypoint": "assets/main.py",
+      "classname": "Main",
+      "intent_filters": [
+        {
+          "action": "main",
+          "category": "launcher"
+        }
+      ]
+    }
+  ]
+}
+
diff --git a/internal_filesystem/apps/cz.ucw.pavel.weather/assets/main.py b/internal_filesystem/apps/cz.ucw.pavel.weather/assets/main.py
new file mode 100644
index 00000000..9258e47d
--- /dev/null
+++ b/internal_filesystem/apps/cz.ucw.pavel.weather/assets/main.py
@@ -0,0 +1,225 @@
+from mpos import Activity
+
+"""
+Look at https://open-meteo.com/en/docs , then design an application that would display current time and weather, and summary of forecast ("no change expected for 2 days" or maybe "rain in 5 hours"), with a way to access detailed forecast.
+"""
+
+import time
+import os
+
+try:
+    import lvgl as lv
+except ImportError:
+    pass
+
+from mpos import Activity, MposKeyboard
+
+import ujson
+import utime
+import usocket as socket
+import ujson
+
+# -----------------------------
+# WEATHER DATA MODEL
+# -----------------------------
+
+class WData:
+    WMO_CODES = {
+        0: "Clear sky",
+        1: "Mainly clear",
+        2: "Partly cloudy",
+        3: "Overcast",
+        45: "Fog",
+        48: "Rime fog",
+        51: "Light drizzle",
+        53: "Drizzle",
+        55: "Heavy drizzle",
+        56: "Freezing drizzle",
+        57: "Freezing drizzle",
+        61: "Light rain",
+        63: "Rain",
+        65: "Heavy rain",
+        66: "Freezing rain",
+        67: "Freezing rain",
+        71: "Light snow",
+        73: "Snow",
+        75: "Heavy snow",
+        77: "Snow grains",
+        80: "Rain showers",
+        81: "Rain showers",
+        82: "Heavy rain showers",
+        85: "Snow showers",
+        86: "Heavy snow showers",
+        95: "Thunderstorm",
+        96: "Thunderstorm + hail",
+        99: "Thunderstorm + hail",
+    }
+
+    def code_to_text(self, code):
+        return self.WMO_CODES.get(int(code), "Unknown")
+
+class Hourly(WData):
+    def __init__(self, cw):
+        self.temp = cw["temperature_2m"]
+        self.wind = cw["windspeed"]
+        self.code = self.code_to_text(cw["weather_code"])
+
+    def summarize(self):
+        return f"{self.code}\nTemp {self.temp}\nWind {self.wind}"
+
+class Weather:
+    name = "Prague"
+    lat = 50.08
+    lon = 14.44
+    
+    def __init__(self):
+        self.now = None
+        self.hourly = []
+        self.daily = []
+        self.summary = "(no weather)"
+
+    def fetch(self):
+        self.summary = "...fetching..."
+
+        # See https://open-meteo.com/en/docs?forecast_days=1&current=relative_humidity_2m
+        
+        host = "api.open-meteo.com"
+        port = 80  # HTTP only
+        path = (
+            "/v1/forecast?"
+            "latitude={}&longitude={}"
+            "&current=temperature_2m,dewpoint_2m,pressure_msl,precipitation,weather_code,windspeed"
+            "&timezone=auto"
+        ).format(self.lat, self.lon)
+
+        print("Weather fetch: ", path)
+
+        # Resolve DNS
+        addr = socket.getaddrinfo(host, port, socket.AF_INET)[0][-1]
+        print("DNS", addr)
+
+        s = socket.socket()
+        s.connect(addr)
+
+        # Send HTTP request
+        request = (
+            "GET {} HTTP/1.1\r\n"
+            "Host: {}\r\n"
+            "Connection: close\r\n\r\n"
+        ).format(path, host)
+
+        s.send(request.encode())
+
+        # ---- Read response ----
+        # Skip HTTP headers
+        buffer = b""
+        while True:
+            chunk = s.recv(256)
+            if not chunk:
+                raise Exception("No response")
+            buffer += chunk
+            header_end = buffer.find(b"\r\n\r\n")
+            if header_end != -1:
+                body = buffer[header_end + 4:]
+                break
+
+
+        # Read remaining body
+        while True:
+            chunk = s.recv(512)
+            if not chunk:
+                break
+            body += chunk
+
+        s.close()
+
+        # Strip non-json parts
+        body = body[5:]
+        body = body[:-7]
+
+        print("Have result:", body.decode())
+
+        # Parse JSON
+        data = ujson.loads(body)
+
+        # ---- Extract data ----
+        cw = data["current"]
+        self.now = Hourly(cw)
+        self.summary = self.now.summarize()
+        
+weather = Weather()
+        
+# ------------------------------------------------------------
+# Main activity
+# ------------------------------------------------------------
+
+class Main(Activity):
+    def __init__(self):
+        self.last_hour = 0
+        super().__init__()
+
+     # --------------------
+
+    def onCreate(self):
+        self.screen = lv.obj()
+        #self.screen.remove_flag(lv.obj.FLAG.SCROLLABLE)
+        scr_main = self.screen
+
+        # ---- MAIN SCREEN ----
+
+        label_time = lv.label(scr_main)
+        label_time.set_text("(time)")
+        label_time.align(lv.ALIGN.TOP_LEFT, 10, 40)
+        label_time.set_style_text_font(lv.font_montserrat_24, 0)
+        self.label_time = label_time
+
+        label_weather = lv.label(scr_main)
+        label_weather.set_text(f"Weather for {weather.name} ({weather.lat}, {weather.lon})")
+        label_weather.align_to(label_time, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 10)
+        label_weather.set_style_text_font(lv.font_montserrat_14, 0)
+        self.label_weather = label_weather
+
+        label_summary = lv.label(scr_main)
+        label_summary.set_text("(weather)")
+        #label_summary.set_long_mode(lv.label.LONG.WRAP)
+        label_summary.set_width(300)
+        label_summary.align_to(label_weather, lv.ALIGN.OUT_BOTTOM_LEFT, 0, 5)
+        label_summary.set_style_text_font(lv.font_montserrat_24, 0)
+        self.label_summary = label_summary
+
+        btn_hourly = lv.button(scr_main)
+        btn_hourly.set_size(100, 40)
+        btn_hourly.align(lv.ALIGN.BOTTOM_LEFT, 10, -10)
+        lv.label(btn_hourly).set_text("Reload")
+
+        btn_hourly.add_event_cb(lambda x: self.do_load(), lv.EVENT.CLICKED, None)
+
+        self.setContentView(self.screen)
+
+    def onResume(self, screen):
+        self.timer = lv.timer_create(self.tick, 15000, None)
+        self.tick(0)
+
+    def onPause(self, screen):
+        if self.timer:
+            self.timer.delete()
+            self.timer = None
+
+    # --------------------
+
+    def tick(self, t):
+        now = time.localtime()
+        y, m, d = now[0], now[1], now[2]
+        hh, mm, ss = now[3], now[4], now[5]
+
+        if hh != self.last_hour:
+            self.last_hour = hh
+            self.do_load()
+
+        self.label_time.set_text("%02d:%02d" % (hh, mm))
+        self.label_summary.set_text(weather.summary)
+
+    def do_load(self):
+        self.label_summary.set_text("Requesting...")
+        weather.fetch()
+        
diff --git a/internal_filesystem/apps/cz.ucw.pavel.weather/res/mipmap-mdpi/icon_64x64.png b/internal_filesystem/apps/cz.ucw.pavel.weather/res/mipmap-mdpi/icon_64x64.png
new file mode 100644
index 00000000..87df6b62
Binary files /dev/null and b/internal_filesystem/apps/cz.ucw.pavel.weather/res/mipmap-mdpi/icon_64x64.png differ