My Journey of Vibe Coding: From Copy-Paste to Building a 3D Desktop Environment

 As we all learn and adapt in this fast-moving tech landscape, one truth has become unavoidable: Artificial Intelligence is now an everyday reality.

AI itself isn’t brand new. The core concepts and theoretical foundations have been around since I was back in secondary school. However, the modern explosion of Large Language Models (LLMs)—kickstarted by OpenAI—opened a completely new window for civilization. It reshaped our paradigm and fundamentally altered how developers think, design, and write software.

As a programmer, system analyst, and system architect, I jumped in early. I may not be an AI researcher training base models from scratch, but as a practitioner and power user, my workflow has undergone a massive transformation.

Here is the story of how I went from manually copy-pasting code snippets to "vibe coding" entire spatial desktop environments.

The Early Days: The Copy-Paste Era

Like many developers, my journey started with the OpenAI ChatGPT web interface.

Back then, dedicated coding agents didn't really exist yet. There was no deep IDE integration, and I hadn't hooked up tools like GitHub Copilot into my day-to-day workflow. My interaction with AI was basic and entirely manual:

1. Describe a bug or ask for a function.

2. Copy the code block.

3. Paste it into my editor.

4. Tweak it when it inevitably broke.

It was useful for quick lookups, but it wasn't a structural game-changer just yet.

Going Local and the Mid-2025 Vibe Coding Shift

Equipped with an AMD Ryzen AI+ Max 395 machine, I began experimenting with local models. But before local AI could fully mature for my daily workflow, gemini-cli arrived, and my real experience with agentic vibe coding officially began.

Working with gemini-cli in mid-2025 was a mix of awe and mild frustration. Early models and agents frequently suffered from context drift, wandering away from the architectural boundaries I had carefully established.

BUT it was still miles ahead of writing code line-by-line.

Projects that previously took me 1 to 2 months were suddenly getting wrapped up in 1 week with significantly higher overall quality.

• My Role: I shifted my focus almost entirely to high-level requirements, system architecture, and code review.

• The Agent’s Role: The agent filled in all the tedious gaps I usually skipped when trying to push out a quick prototype—plugging memory leaks, polishing UI components, and wrangling complex CSS layouts.

The Quotas, aether.ing, and the Quest for Local Autonomy

As I began juggling 2 to 3 active projects at a time, Google was incredibly generous with gemini-cli. But good things in tech rarely stay unchanged for long. Google eventually transitioned to Antigravity 2.0, introducing strict quota limits even for Workspace users on Pro plans.

Meanwhile, the AI arms race between OpenAI, Anthropic, and Google accelerated wildly. Model after model hit the market. While everyone was raving about flagship cloud models like Opus, I tried to stay optimistic about local AI to avoid accumulating monthly SaaS subscriptions.

I even started building my own custom agent platform, aether.ing, aiming to empower my workflow using local LLMs hosted on my home server.

However, as the generous gemini-cli tier ended and Antigravity 2.0 proved too restrictive for heavy architectural sessions, I found local LLMs struggling under the weight of complex agentic demands. I experimented extensively with HuggingFace community fine-tunes of Qwen 3.5 and 3.6, but running local 27B or 120B parameter models felt like bringing a knife to a gunfight when compared to the massive remote models being deployed. When Alibaba released Qwen 3.8 at 2.4 Trillion parameters and Kimi launched K3 at 2.8 Trillion parameters, I had to admit reality: my local hardware couldn't keep pace for deep multi-file refactoring. I postponed heavy vibe coding objective on aether.ing, paring its role down to creative co-writing.

The Turning Point: Chipping In for Fable 5 & Opus 5

After hearing endless chatter about the architectural reasoning capabilities of Anthropic's latest models, the release of Fable 5 (with a trial for Pro subscribers) pushed me over the edge. I decided to chip in $20 to test the waters.

The results were staggering.

Case 1: jWebDBAdmin

I had an old, unpolished internal tool named jWebDBAdmin. It had been used by me and a few colleagues for a long time, carrying hundreds (if not thousands) of lines of legacy code. I wanted to add new features, but I was too tired to sink hours into manual refactoring.

I fed jWebDBAdmin to Fable/Opus with a wishlist of major new requirements. In just two 5-hour sessions, the model completely rebuilt the project from the ground up—adding auto-complete, sleek UI polish, and intelligent AI-assisted query suggestions.

Case 2: Applikasi KTG & Vibrefy

• Applikasi KTG: Complex feature sets that used to take 1–2 weeks of manual vibe coding were added and verified in just 2 days.
• Vibrefy: A personal project I had sitting in a drawer for months was completely polished, structured, and uploaded to GitHub directly with the help of the agent.

The Hidden Perk: Automated Git Plumbing

As a developer who never enjoyed dealing with the tedious overhead of Git branching, merge conflicts, and commit management, using agents like Claude Code took that pain away entirely. The agent handles all the Git plumbing while I focus on design decisions.

Going Wild: From Web Apps to 3D Spatial Computing

Once you realize you can build outside your traditional domain knowledge, things get exciting fast.

The Android Media Problem (Vibrefy Mobile)

I had media files encoded in AC3 audio that couldn't play natively inside Android's Google Chrome. I wanted a custom player, so I decided to build a dedicated Android client for Vibrefy.

The catch? I had zero prior experience in native Android development.

With the AI agent handling the framework specifics, we pushed far beyond a standard player. Why stop at standard 2D video? We transformed it into a full 3D and VR media player with support for Nreal / Xreal Air AR glasses—something impossible inside a standard web browser.

The Ultrawide Debugging Need (HoloFrame)

Using the Xreal Air glasses with a Mac presented another roadblock. While Xreal offers Nebula for Mac with virtual screens, the resolution limits made reading long, dense log files during debugging nearly impossible. I needed a single wide canvas where I could read an entire log line from left to right without truncation.

My goal: A virtual desktop canvas running at 7680 × 2160 resolution.

That project became HoloFrame, giving me the exact high-density virtual display real estate I needed for heavy debugging sessions.

The Ultimate Challenge: Spatiand (A 3D Desktop from Scratch)

Eventually, relying on existing host operating systems and window-capture software felt too limiting. Most AR/VR desktop setups use window-capture: rendering an app to a 2D desktop buffer, capturing the pixels, and re-projecting the frame into 3D space. It is inefficient and clunky.

I wanted true spatial computing: an lightweight OS environment where applications directly draw inside 3D space.

After brainstorming hardware options—and guided by ChatGPT's memory of my previous setups—I settled on my target rig: a mobile Mini-PC setup combined with my SteamDeck (running SteamOS) and Xreal Air glasses.

Then came the craziest prompt I've ever thrown at Opus 5: Build a 3D desktop environment from scratch with minimal external dependencies, targeting SteamOS and Xreal Air.

This wasn't a project solved in 2 days, or even a week. I’ve had to fight through strict 5-hour messaging limits and weekly quota caps while balancing side projects. But step by step, byte by byte, it's coming together.

Conclusion: Focus on Architecture, Let the Vibe Flow

Vibe coding isn't about letting an AI blindly write code while you sit back and sleep. It’s about elevating your role as a software builder.

By letting high-tier LLM agents handle syntax, framework boilerplate, UI styling, edge-case memory safety, and Git operations, I am free to spend 90% of my time doing what I love: system architecture, creative hardware integration, and solving real user problems.

Stay tuned—Spatiand will be landing on GitHub soon!

Introducing Aether: The Open-Source Workspace Powered by AI

Managing digital workspace assets across local drives, remote servers, cloud platforms, and AI tools often feels fragmented. Aether is an open-source platform designed to unify your files, remote environments, workflows, and AI assistants into a single, cohesive experience.

Whether you need to manage distributed files, interact with smart AI agents, or run terminal sessions directly from your browser, Aether brings your workspace tools under one roof.

What Makes Aether Unique?

1. Unified Multi-Storage Access

Aether breaks down silos between storage services. Instead of juggling different tabs and cloud providers, Aether lets you seamlessly interact with local file systems, remote environments via SSH, and cloud storage like Google Drive inside one clean interface.

2. Embedded AI Assistants & Specialized Agents

Aether goes beyond standard file management by embedding AI into your daily tasks. From co-writing assistants and general helpers to specialized AI agents tailored for coding and productivity, smart assistance is always integrated directly alongside your files and documents.

3. Web-Based Terminal & Real-Time Connectivity

Work with your connected servers and local tools without leaving your browser. Built-in interactive terminal support and real-time updates provide a smooth, responsive workspace experience without requiring complex desktop setups.

4. Flexible Authentication & Customization

Designed for flexible deployment, Aether supports OpenID authentication, user setting controls, and modular provider configurations, making it easy to adapt to both individual needs and team environments.

Why Open Source?

Workspace management and productivity platforms should be transparent, extensible, and community-driven. Releasing Aether as open-source allows developers, creators, and power users to inspect, customize, and shape the future of unified digital workspaces together.

Whether you want to build custom AI agent skills, integrate new storage providers, or host Aether on your own infrastructure, the project is open for everyone.

Get Started

Aether is now live and available for self-hosting, testing, and contribution.

• Explore the Project: Check out the source code, installation steps, and technical architecture guidelines directly on GitHub.

• Get Involved: Report issues, suggest new features, or submit pull requests to help expand Aether's capabilities.

Welcome to a more connected way to work. Welcome to Aether.

How I Used Vibe Coding to Build HoloFrame: Bringing Big-Screen AR Back to Mac

 Like many people who picked up a pair of Xreal AR glasses, I had one simple dream: a massive, high-resolution virtual screen hovering right in front of my eyes wherever I opened my Mac. No bulky external monitors, no wasted desk space—just a giant floating workspace that goes wherever I do.

When Xreal originally launched their Nebula app for macOS, it felt like the future was finally here. But over time, official support waned, updates stalled, and the app became increasingly difficult to rely on. My glasses were slowly turning into an expensive pair of standard sunglasses sitting next to my laptop.

Instead of waiting for an official fix that might never come, I decided to build my own solution: HoloFrame.

Letting AI Do the Heavy Lifting: Enter "Vibe Coding"

If you told me a few years ago that I’d write software to communicate directly with hardware glasses, I probably would have laughed. Building something like this requires getting under the hood of hardware engineering:

• Decoding low-level USB HID protocols to talk to the glasses directly.

• Extracting raw IMU sensor data (accelerometers and gyroscopes).

• Performing complex 3D math and view-smoothing calculations so the screen stays firmly anchored in virtual space without making you feel motion sick.

Ordinarily, figuring out those low-level protocols and spatial calculations would require weeks of reading hardware specs and brushing up on advanced trigonometry. But in the era of vibe coding, I didn't need to write every line of math by hand.

I acted as the architect—defining the vision, testing the behavior, and steering the direction—while letting AI handle the grueling USB protocol plumbing and real-time head-tracking logic.

Meet HoloFrame

The result of this experiment is HoloFrame, a lightweight native Mac application designed to give you back your virtual multi-monitor experience.

Here is what HoloFrame brings to the table:

• Instant Big Screen Virtualization: Turns your Xreal glasses into a massive, crisp virtual display for macOS.

• Smooth Head Tracking: By leveraging custom sensor fusion and view smoothing, the screen stays pinned in mid-air seamlessly as you turn your head.

• Lightweight & Native: Built specifically for macOS, bypassing bloated frameworks to keep CPU usage low and battery life high.

• Zero Frustration: Plug in your glasses, launch the app, and get straight to work.

Why This Project Matters

HoloFrame started as a personal itch to fix a broken workflow, but it ended up demonstrating something bigger: hardware is no longer locked behind wall-off ecosystems.

When hardware companies move on or stop updating their software, community-driven development can step in. With AI acting as an assistant for low-level protocol decoding and mathematical crunching, building tailored software for your favorite gadgets is more accessible than ever.

If your Xreal glasses have been gathering dust because of unsupported Mac software, it's time to wipe them off. HoloFrame is here to give you back your workspace.

Check out the repo, try it out, and let me know how it works for your daily workflow!

Hemera — A Lightweight Bridge for Local & Cloud AI Models

Running local LLMs often means dealing with moving targets. Runtimes like llama.cpp move at a breakneck speed—sometimes releasing multiple builds in a single day. While that pace brings support for new quantizations immediately, an engine update today can easily break or regress a model that ran perfectly yesterday.

On top of that, managing different GPU backends (CUDA, ROCm, Vulkan), missing dynamic libraries, and setting up models for different client tools usually means juggling multiple local setups.

If you want to run local GGUF models—or route to cloud providers—without worrying about an engine update breaking your setup, you quickly run into friction.

That's why I came with idea of Hemera—a flexible local AI engine manager, wrapper, and proxy router written in Java.

The Spirit of the Project

The philosophy behind Hemera is simple: unify your AI tooling into one quiet, self-contained service.

Instead of juggling different local wrappers or hardcoding provider-specific integrations into your apps, Hemera sits in the middle. It acts as both a local engine orchestrator and a multi-dialect API translator.

I wanted a tool that:

• Doesn't force a framework on you: Zero external dependencies—no Maven, no Gradle, no heavy web frameworks, and no npm build step. Just JDK 21+ and a single 112 KB JAR file.

• Never deletes what worked: Engine builds live side-by-side. Updating llama.cpp never removes older versions, so if a new build misbehaves, you can roll back or pin a model to a previous tag in one click.

• Handles local & remote natively: Reads local GGUF files directly, manages backends (CUDA, ROCm, Vulkan) per model, and makes remote models (DeepSeek, OpenAI, Gemini, Claude) look like local endpoints.

Key Features

• One Endpoint, Three Dialects: Supports Ollama, OpenAI, and Anthropic Claude endpoints on a single port (12434). Every tool in your stack—from the native ollama CLI to Claude Code—can drive your models.

• Engine Versioning & Rollbacks: Keep multiple engine releases and GPU backends (ROCm, CUDA, Vulkan, SYCL, CPU) installed simultaneously without interference.

• Smart GPU Discovery (ELF Header Inspection): If a GPU build is missing vendor dynamic libraries, it often quietly falls back to CPU execution at a crawl. Hemera reads ELF headers on startup, detects missing .sodependencies, searches system paths, and automatically sets LD_LIBRARY_PATH for that process.

• Virtual Model Aliases: A single GGUF file can be configured as multiple named models—each with its own context size, GPU offload settings, chat templates, and environment variables.

• Native GGUF Inspection & Safe Deletion: Built-in direct GGUF header reading (GgufReader.java) parses metadata without external CLI tools. Deleting a model in the UI only drops the configuration, keeping expensive GGUF files safe.

• Minimalist Web Dashboard: An embedded, zero-framework web UI (vanilla HTML/CSS/JS) that follows your OS light/dark theme for monitoring running models, engine PIDs, and proxy settings.

Under the Hood (Architecture)

Hemera’s codebase is structured around a few core modules inside ing.aether.hemera:

ing.aether.hemera
├── api         # API dialects (OpenAI, Claude, Ollama) & Proxy Dispatcher
├── engine      # Engine downloaders, ELF/Tar handling, Instance lifecycle
├── model       # Bare-metal GGUF reader & Model Registry
├── http & json # Custom HTTP router & lightweight JSON engine
└── web         # Admin REST API endpoints & static dashboard assets

1. The Proxy & API Layer (hemera.api): Intercepts incoming requests, normalizes payloads via ProxyDispatcher, translates between protocols on the fly, and routes requests to local processes or cloud APIs while preserving Server-Sent Events (SSE) streaming.

2. The Engine Orchestrator (hemera.engine): Manages executable runtimes. It resolves required native shared libraries (LibraryResolver.java), handles binary archives (Tar.java), and manages the lifecycle of local engine processes (InstanceManager.java).

3. The Model Registry (hemera.model): Instead of relying on external CLI tools to inspect files, ModelScanner searches local directories and uses GgufReader to parse tensor metadata directly from binary headers to feed the central registry.

4. Core Infrastructure (hemera.http & hemera.json): Powered by a custom hand-rolled JSON parser and HTTP router running on Java's virtual threads for maximum efficiency.

Check out the code on GitHub: github.com/peprasetya/hemera

Vibrefy — a media server that doesn't watch you back

I finally open-sourced something I've been running for myself for a while: Vibrefy, a lightweight, self-hosted media server. Code's up on GitHub: github.com/peprasetya/Vibrefy.

The short version: it streams video from a local library, or from your own cloud storage (currently support: Google Drive, OneDrive, pCloud, or FileLu account), straight to the browser. The server proxies everything, so nothing but the video itself ever leaves it.

Why build another one, when Plex/Jellyfin/Emby already exist?

Two opinions I couldn't shake:

No database. Every media server I've used runs a database in the background — cataloguing, indexing, building a profile of what you watch. Vibrefy doesn't. Configuration lives in one JSON file, and the only per-user state is a small encrypted file that remembers where you left off in something, so it can resume it. That's it. No schema, no service to babysit, no "backup strategy" beyond copying a folder. You can move the whole install by dragging it to another disk.

The honest trade-off: there's no watch history, and nothing being collected to guess what you'll like next. If you want a recommendation engine, this isn't it. If you want something you can fully understand and hand to a friend without explaining a database schema, that's the whole point.

Landscape covers. Every media server inherits the vertical movie-poster look, because that's what DVD boxes and cinema posters happened to be shaped like. It's a strange default for something rendered on a screen. Vibrefy generates its thumbnails in 16:9, matching the video itself — so browsing looks like a shelf of screens, not a shelf of posters.

What it actually does:

• Browse and stream a local library, with resumable playback per file
• Mount your own cloud storage (currently support: Google Drive, OneDrive, pCloud, FileLu) and browse it exactly like a local folder
• Auto-play the next episode of a series
• Subtitles pulled straight out of the video container
• Cast to AirPlay, fullscreen, or Picture-in-Picture straight from the player
• OpenID login, first-run setup, no manual account provisioning, no password.

It's Java EE under the hood — Jakarta Servlets, JSP, vanilla JS, no framework sprawl — MIT licensed. Feedback, issues, and PRs welcome.

JWebDBAdmin, 21 Years Later: I Finally Reinvented It

 

Some background

Back in 2010 I wrote about a project I'd already called "very outdated" — a little web-based SQL runner I built in 2005 because I was tired of juggling database clients for every engine my company touched. I said then: "there is no more development."

That was true for sixteen more years.

The old JWebDBAdmin never actually died, though. It kept quietly running in production the entire time. I still used it weekly. I just stopped touching the code — except for the occasional patch nobody wrote a blog post about, like swapping the login screen from a plain username/password form to Google sign-in, back when that became the sane thing to do instead of storing another password nobody would rotate.

This year I finally reinvented it. Not a patch this time — a full rewrite, from a blank editor, but built on top of two decades of "I should really fix that" notes I never had time to act on in 2005. Everything got a second chance to be done right.

Why bother, 21 years later?

Honestly — because I could finally build the version I wanted in 2005 but didn't have time for. And because AI coding assistants make "let me just rewrite this properly" a weekend project instead of a quarter.

I also gave myself one hard rule this time: zero dependencies. No Maven, no Spring, no npm, no CSS framework, no JS library. Just plain Java servlets and plain HTML/CSS/JS. Partly discipline, partly spite toward every project I've inherited that needed forty transitive dependencies to render a table.

What's actually new

• SQL autocomplete that knows your schema. Not just keywords — it knows your tables, your columns, and resolves aliases. Type a. after ... FROM agents a and it lists agents' columns. Type Sele and hit tab, it hands you SELECT * FROM [table] WHERE with your cursor already in the right slot.
• Edit results in place. Double-click a cell in a single-table SELECT with a primary key, change the value, hit Enter. No separate "edit mode."
• Favorites your non-technical coworkers can actually use. Save a query with {{param}} placeholders and they render as input boxes. Nobody has to know what a WHERE clause is.
• An AI assistant that's actually useful, not a gimmick. Point it at any OpenAI-compatible endpoint — including a local Ollama, so your schema and data never leave your network. It knows your table structure, your indexes, your current query. Ask it a question in plain English and read-only queries just run; anything that changes data comes back as a suggestion you review and send to the editor yourself. It never executes a write on its own. And when a query fails, it looks at the error and offers a fix without you having to ask.
• A destructive-query guard that's actually enforced server-side — DELETE/DROP/TRUNCATE are off by default, and turning them on is a config change, not a UI toggle someone can click by accident.
• Login through Google, no passwords at all. Nothing to store, nothing to leak, nothing for someone to reuse from another breach. You're pre-registered by email and that's the whole account system.
• Dark mode that follows your OS, because I got tired of every "dark theme" secretly being navy blue.
• Still a one-file drop-in deploy. Same database schema as always — your existing users, favorites, and history just work. If you're one of the three people who used the original: nothing to migrate.

Try it

Source, MIT licensed: github.com/peprasetya/jWebDBAdmin

First release, tagged and ready to drop into Tomcat: v20260720 release

The original 2005 project stays up on SourceForge as an archive — this is where it actually lives now.

If you've got a Tomcat instance lying around and five spare minutes, it's a two-file deploy: drop in the WAR, drop in a properties file. Would genuinely like to know if it's useful to anyone besides me — that's most of the point of putting it on GitHub this time instead of leaving it running quietly for another 21 years.

Introducing urlNeXT v2.0.0 – The Ultimate Sequence Navigator Upgraded to Manifest V3

It has been quite a while since I first built urlNeXT, but I recently decided to dust off this old project and give it a modern overhaul. Today, I am excited to announce the release of urlNeXT version 2.0.0!

If you frequently browse web galleries, documentation, forum threads, or multi-page search results, this extension was built to save you a ton of clicks.

Here is a breakdown of what’s new, how it works under the hood, and why this version is lighter and faster than ever.

What is urlNeXT?

At its core, urlNeXT is a universal sequential navigation utility. It helps you jump to the "next" or "previous" page automatically without needing to hunt down the page's native pagination links.

It works using a two-tier strategy:

1. Smart DOM Detection: It scans the web page for native pagination anchors (like Google, Bing, or Yahoo search pages, Blogger pages, or standard rel="next" / rel="prev" tags).

2. Intelligent URL Sequencing (Fallback): If the website doesn't have explicit next/prev links, urlNeXT parses the active URL string, finds numeric sequences (e.g., page=1, 001.jpg), and mathematically increments or decrements that number to transition you forward or backward.

What's New in Version 2.0.0?

1. Full Migration to Manifest V3 (MV3)

Google is phasing out older extension formats, so urlNeXT has been completely "rewritten from scratch" (a.k.a: writing prompt from scratch to Gemini to do the upgrade 😜) to adhere to modern Manifest V3 architecture. The extension now relies on a streamlined service worker structure that keeps background memory usage close to zero when you aren't actively navigating.

2. Lightweight & In-Memory Operation

urlNeXT is designed to have a near-zero footprint on your system resources. It doesn't bloat your browser or hog memory because it handles all logic dynamically. No data is ever written to your disk, and no persistent logs are kept. All active tab states are processed temporarily in-memory and completely vanish the moment you close the tab or your browser session.

3. Expanded Out-of-the-Box Pagination Support

The content scanning engine has been refined to instantly support major search providers and publishing layouts:

• Google Search: Seamless tracking using Google's native pagination targets (pnnext/pnprev).

• Bing & Yahoo Search: Direct support for native pagination classes and element layouts.

• Blogger / Blogspot: Automatic extraction of older/newer post navigation paths.

• Standard Web Standards: Universal parsing for explicit rel="next", rel="prev", and textual indicators (like Next > or « Prev).

How to Use urlNeXT

⌨️ Keyboard Navigation

If you prefer keeping your hands on the keyboard, you can navigate without touching your mouse using these global shortcuts:

• Next Page: Alt + Shift + Ctrl + Right Arrow

• Previous Page: Alt + Shift + Ctrl + Left Arrow

• Force Re-Scan: Alt + Shift + Ctrl + O (forces a refresh scan of the current page's links)

🔬 Single-Click Action Overlay

Clicking the extension icon in your toolbar will immediately execute the default directional navigation. When a page transition triggers, a clean, high-contrast animated arrow overlay renders on screen, indicating exactly which direction you are flipping through the sequence.

🎛️ Tab-Bound Configuration

If a URL features multiple numeric sequences (for example, website.com/chapter-05/page-001.html), you can open the extension's Options Page to customize your experience.

The options window will display a visual split of your current URL. You can simply click on the specific number block you want to target (e.g., locking onto the page number instead of the chapter number) and configure whether the default click action moves you forward (+1) or backward (-1). Remember: these settings are non-persistent and uniquely bound to that specific tab session.

Privacy & Security Commitment

Because everything runs 100% locally within your browser code package, urlNeXT does not track, collect, or transmit a single byte of your browsing data. There are absolutely no third-party analytic trackers, no external network requests, and zero remote code payloads.

Check out the updated code, give it a spin on your favorite multi-page forums or image galleries, and let me know your thoughts or feedback in the comments below!

Privacy Policy for urlNeXT Chrome Extension

 This privacy policy governs your use of the urlNeXT extension for Google Chrome.

1. Information Collection and Use

urlNeXT does not collect, store, or transmit any personal data or browsing history. * Local Processing Only: The extension operates entirely within your local browser environment. It reads the URL and DOM elements of your active tab solely to calculate and execute sequential page transitions (e.g., moving to the next page number).

• Temporary State: Any state tracking (such as identifying which part of a URL to change) is stored strictly in-memory within the browser background session and is cleared automatically when the extension or browser is closed.

2. Data Transmission and Third Parties

• No Remote Servers: urlNeXT does not communicate with any external or remote servers.

• No Third-Party Analytics: We do not use third-party tracking, analytics tools, or advertising networks. Your data never leaves your personal device.

3. Permissions Justification

Our extension utilizes specific browser permissions to function properly:

• Tabs: Used exclusively to look at the current page URL to find sequential numbers and navigate your active tab forward or backward.

• Host Permissions (All Sites): Required so that the sequence navigator utility can function on any paginated website or web forum you choose to use it on.

4. Changes to This Privacy Policy

We may update our Privacy Policy from time to time. Any changes will be posted directly on this page. Your continued use of the extension constitutes your agreement to the local processing model outlined above.

5. Contact

If you have any questions or feedback regarding this extension, feel free to drop a comment or contact the developer directly through this blog.

eProKar Privacy Policy

 (English Version is below)

Kebijakan Privasi eProKar

eProKar adalah sebuah ekstensi peramban (Browser Extension) yang ditujukan untuk mempermudah pemakaian aplikasi SAPA (Sistem Aplikasi Program Karya Pelayanan dan Anggaran) yang disiapkan Keuskupan Agung Jakarta.

Kebijakan privasi untuk eProKar menyatakan bagaimana dan kenapa, ada kemungkinan, kami mengumpulkan, menyimpan, dan/atau membagikan informasi yang ada, ketika ekstensi peramban digunakan.

Informasi Personal apa saja yang dikumpulkan? 

Kami tidak melakukan pengumpulan data. eProKar sepenuhnya berjalan pada peramban (browser) yang terpasang, seluruh data diproses pada saat peramban membuka halaman SAPA. eProKar dapat mengambil data dari server SAPA untuk diproses lebih lanjut hanya pada peramban terkait.

Apakah ada informasi yang dibagikan kepada pihak lain?

Tidak ada informasi yang dikumpulkan, dan tidak ada informasi yang dibagikan kepada pihak lain. Seluruh data yang diproses eProKar hanya diproses secara lokal dan tidak dikirim ke tempat lain.

Bagaimana pengamanan informasi yang ada?

eProKar berjalan dalam peramban (browser) dengan standar keamanan dari peramban. eProKar dibuat tanpa pengaturan izin untuk akses jaringan di luar web SAPA, sehingga eProKar tidak dapat mengakses server lain selain SAPA.

Apakah kebijakan privasi ini akan berubah?

Ya, kebijakan privasi ini akan berubah sesuai kebutuhan dan berdasarkan fitur yang ada dan yang akan ada Setiap kebijakan akan selalu pengikuti peraturan yang ada.

Bagaimana menghubungi kami terkait kebijakan privasi ini?

Jika ada pertanyaan, saran, dan masukan, silahkan menghubungi kami:

paulus.prasetya@yakobus.or.id

paulus@prasetya.id

eProKar Privacy Policy

eProKar is a browser extension that made to ease usage of web application SAPA (Sistem Aplikasi Program Karya Pelayanan dan Anggaran) that prepared by Archdiocese of Jakarta.

This eProKar privacy policy, describes how and why we might collect, strore, use, and/or share your information when using this browser extension.

What personal information that we collect?

We do not collect any data. eProKar fully run on browser that installed with. All data are processed when the browser open pages of SAPA. eProKar may get more information from SAPA Server to be processed only in the browser.

What information that shared with third parties?

There is no information being collected nor shared with any parties. All data are processed locally and never sent to anywhere.

How do we keep your information safe?

eProKar run within the browser with the browser standard security. eProkar is made without permission to access network outside SAPA web, so eProKar never able to send anything to any server beside SAPA.

Do we make updated to this policy?

Yes, this privacy policy will be updated according needs and based on feature and future feature. Every policy will always comply with relevant laws.

How to contact about this policy?

If there any question, comments, and suggestion, please contact us:

paulus.prasetya@yakobus.or.id

paulus@prasetya.id

Installing Linux Lubuntu 18.04.01 on Lenovo MIIX 320

I was looking for a cheap lightest notebook, not really looking for specific brand or spec. When a web suggest some choice, I forgot what is it, then my decision fall into Lenovo Miix 320. In my country, the notebook come with 2GB RAM, and 128 GB eMMC configuration. It come preinstalled with Windows 10, and I expect I would rid it off at the first attempt, cause I know the OS is power hungry for 2 GB RAM, and I do not want to deal with all the bad things happen in Windows environment. You know, Windows always need antivirus to run over time, which will consume the already limited processing power and resources, and many-many other things that Microsoft still failed to make OS as thin as Win XP (IMHO and subjective, Win XP feels good at 512MB RAM-without anti-virus and stable enough until it become un-supported OS and Microsoft stop patching it).

After I decided the laptop, I search for some success story installing linux on the machine, so I found:

• https://esc.sh/blog/linux-on-lenovo-miix-320/ by Mansoor
• https://telegra.ph/Installing-Lubuntu-1710-on-the-Lenovo-Miix-320-ICR-01-19 by xowl

None promise a smooth installation and both confirm at least Camera and SD Card slot would not work. For the records, I choose LXDE for my all Linux desktop, as based on my experience, it is  lighter than XFCE,Gnome/Mate but still give simplicity experience than other lightweight Windows Manager. 

To be note, this article is made based on the both link above with additional some change that I made. Some information are copied here as for archive in case the links above become inaccessible.

Preparation

Download the Lubuntu Desktop 64-bit from:

https://lubuntu.net/downloads/

And write the image to USB either using dd on mac/linux, and for me it's my first using Etcher on the preinstalled Windows 10. 

On Windows 10, we need to shrink the partition of the Windows, just decided how many partition that you need for your linux. On my case, as I have 128 GB eMMC version, I decided to give linux 32GB. So the Windows partition is reduced using Disk Management less 32GB.

Still on Disk Management, turn off the BitLocker. This step is needed when you want to dual boot, as we will turn off the secure boot on the Lenovo bios. Turning BitLocker off, you will loose the encryption feature on the Windows partition.

Once the partition conversion done, you can restart the windows to make it boot from bios. Press the Volume-Up button while it restart. There are some other way like from Windows 10 Setting, Recovery boot...etc... (I'm already forgotten when I make this article)

On the BIOS, make sure to turn of the Secure Boot. You would not able to boot to the USB if Secure Boot still on. Save and boot again, hold the Volume-Up Button to come the BIOS again, select boot device then your USB drive.

Boot to Installation Image

On first boot, You will greeted by Installation grub. DO NOT press enter directly. You need to edit the boot parameter by press e to come to edit entry.

Before the line that starts with linux, add:

set gfxpayload=keep

At the end of the line that starts with linux, add:

nomodeset i915.modeset=1 fbcon=rotate:1

So they will lookalike:

set gfxpayload=keep linux /casper/vmlinuz.efi file=/cdrom/preseed/ubuntu.seed boot=casper quiet splash nomodeset i915.modeset=1 fbcon=rotate:1 ---
Continue to boot. You may ended do the installation in portrait mode. This because the Ubuntu recognize the default screen as in portrait mode. Once done, you will boot it, and when in grub, you need do the exactly as above on the first boot, edit the boot parameter by press e.

Note: After the boot, You will have a black/blank screen. Just close the lid for some seconds and open it again (some time need 2nd attempt). You should see the login screen in portrait mode. Just login in any way you feel possible, then open terminal (Ctrl-Alt-t)and use xrandr to rotate the screen:

xrandr -o right

The command above will only rotate the screen, but it would not rotate the digitizer of the touch screen, so you will loose it for a while.

Fixing things

Now times to make some fix to the linux to adapt with the hardware. As most (if not all) of the commands below need root permission, we would become root by:
sudo su

It's much easier to manage things as root user rather than we type sudo multiple time on multiple commands. So commands below are run as root!!

grub

nano /etc/default/grub

Change or add the following lines:

# This to remove the splash screen
GRUB_CMDLINE_LINUX_DEFAULT=""
# 2 Lines below are as adviced by Mansoor, there are explanation on his web.
GRUB_CMDLINE_LINUX="nomodeset i915.modeset=1 fbcon=rotate:1"
GRUB_GFXPAYLOAD_LINUX=keep

Press Ctrl+x and then y and press Enter to save it.

To make the boot show the right text, we still need to hack the grub update script. FYI, this hack should be not recommended, but it's not covered with the /etc/default/grub. Because somehow the grub can show in landscape mode, but after, the kernel recognize the screen in portrait mode.

nano /etc/grub.d/10_linux

## commented line 154 about setting gfxmode, so become:
#echo " gfxmode \$linux_gfx_mode" | sed "s/^/$submenu_indentation/"
# Then add (note: space after first double quote is tab, to keep the file look nice):
echo " set gfxpayload=keep"
echo " gfxmode 800x1280"

Press Ctrl+x and then y and press Enter to save it.

Then update the grub with command:

update-grub

initramfs

I do not really know if this part would took effect, but as xowl advice about the backlight and blanking during boot, I was applied this part. In the end, related or no, I can do backlight controls in the X.

cd /etc/initramfs-tools
nano initramfs.conf

Change the line:

MODULES=most

to

MODULES=list

Press Ctrl+x and then y and press Enter to save it.

lsmod | cut -d ' ' -f  1| sudo tee -a modules
nano modules

Change the line (actually remove the header):

Modules

to (and add this line, on my case, I have same module below so I doubled it):

pwm-lpss
then find a like that says i915 and remove it.

Press Ctrl+x and then y and press Enter to save it.

And update the initramfs with command:

update-initramfs -u

X configuration

As advised by Xowl, create file /usr/share/X11/xorg.conf.d/11-miix320.conf

nano /usr/share/X11/xorg.conf.d/11-miix320.conf
Section "Monitor" Identifier "<default monitor="">" DisplaySize 339 212 # 144 DPI Option "Rotate" "right" EndSection Section "Device" Identifier "Intel Graphics" Driver "intel" Option "AccelMethod" "sna" Option "TearFree" "true" EndSection Section "Screen" Identifier "Default Screen" Monitor "<default monitor="">" Device "Intel Graphics" DefaultDepth 24 SubSection "Display" Depth 24 Modes "1024x768" "800x600" EndSubSection EndSection
Press Ctrl+x and then y and press Enter to save it.
Notice the: Option "Rotate" "Right", this is to rotate the screen from portrait to landscape.

I prefer to use xorg-input-libinput rather than xorg-input-synaptic as the libinput have built-in 'disable touchpad while typing' rather we need to invoke another process syndaemon for synaptic, beside libinput is loaded too for the touchscreen. So move all the synaptic config file out, or you can delete them, or even remove the package.

mv /share/X11/xorg.conf.d/*synaptics* /usr/share/X11/

Then we need to 'rotate' the digitizer of the touchscreen and also modify on the touchpad options.

Add this to the touchscreen section:
Option "TransformationMatrix" "0 1 0 -1 0 1 0 0 1"

So it will look like:

Section "InputClass" Identifier "libinput touchscreen catchall" MatchIsTouchscreen "on" MatchDevicePath "/dev/input/event*" Driver "libinput" Option "TransformationMatrix" "0 1 0 -1 0 1 0 0 1" EndSection

And add these to the touchpad secion:
Option "Tapping" "on"
Option "NaturalScrolling" "on"

The natural scrolling is to invert the scroll, you may prefer to turn it off.
So the section will look like:
Section "InputClass" Identifier "libinput touchpad catchall" MatchIsTouchpad "on" MatchDevicePath "/dev/input/event*" Driver "libinput" Option "Tapping" "on" Option "NaturalScrolling" "on" EndSection

Press Ctrl+x and then y and press Enter to save it.

When I write this article, the hard-click on the touchpad/clickpad still not work, either incompatible with the kernel or the libinput driver.

Blank/Black Screen on reboot

As on the first boot after the installation, the lid need to close then open again, it somewhat like triggering the DPMS off with close then on with the lid open. So we need to firing the event by scripts. This part may differ with different distro even Ubuntu variants may use different script name, but basically, we need to call command:

xset dpms force off && sleep 1 && xset dpms force on

Just after the X started and need be called by the Display Manager.

LUbuntu is use lightdm as Display Manager. As in documentation, lightdm have config display-stopped-script and greeter-setup-script, but none is work for me. And I found it call command 'upstart'. So I just create script /bin/upstart

nano /bin/upstart

#Force DPMS off then On xset dpms force off && sleep 1 && xset dpms force on #Just to log when this script is called date >> /tmp/upstart.log

Press Ctrl+x and then y and press Enter to save it.

chmod +x /bin/upstart

This script is not perfect, as it will be called when boot and every time screen being locked and user log-off, while actually it just need to be called once at very first boot.

Volume Controls

Volume controls is not run out of the box and the default LUbuntu is not work, we need to use XFCE daemon:

apt install xfce4-volumed

And with GUI:

1. Open the 'Start Menu' -> Preferences -> Setup Hot Keys
2. Open the 'Programs' tab
3. Remove the lines with Open the 'Programs' tab
• XF86AudioRaiseVolume
• XF86AudioLowerVolume
• XF86AudioMute
4. SAVE, then close the window
5. Open the 'Start Menu' -> Preferences -> Default applications for LXSession
6. Go to the 'Autostart' tab
7. In the 'Known Applicaions' part, put a tick near the 'XFCE Volume Daemon'
8. Close the window

Battery Gauge

Battery Gauge was work out of the box at the first days I use the Miix 320, but after it stop to work. So I took xowl's advice. This is more a hack rather a solution, as this make a script keep running all over the time although most being slept. I change the original script from sleep 10 seconds to 30 seconds.
Please note, the script have more lines than the visible, scroll or select all in the text area.

apt install i2c-tools

nano /opt/axpd.sh

#! /bin/bash #Based on https://github.com/Icenowy/axpd/blob/master/axpd.sh hex2dec(){ echo 'ibase=16; obase=A; '"$1" | bc } checkbit(){ [ $(( $1 & $(( 1 << $2 )) )) != 0 ] } rmmod -f battery 2>/dev/null modprobe i2c-dev 2>/dev/null modprobe test_power 2>/dev/null for i in 4 12 6 do if find /sys | grep axp288_charger | grep -q i2c-$i/ then export ADDR=$i fi done i2cset -f -y -r 6 0x34 0xb8 0xe8 while true do rmmod battery 2>/dev/null echo LION > /sys/module/test_power/parameters/battery_technology source_status_reg=$(i2cget -f -y $ADDR 0x34 0x00) charger_status_reg=$(i2cget -f -y $ADDR 0x34 0x01) if checkbit $source_status_reg 4 then echo on > /sys/module/test_power/parameters/usb_online if checkbit $charger_status_reg 6 then echo charging > /sys/module/test_power/parameters/battery_status else echo not-charging > /sys/module/test_power/parameters/battery_status fi else echo off > /sys/module/test_power/parameters/usb_online echo discharging > /sys/module/test_power/parameters/battery_status fi if checkbit $source_status_reg 2 then echo on > /sys/module/test_power/parameters/ac_online else echo off > /sys/module/test_power/parameters/ac_online fi hex=$(i2cget -f -y $ADDR 0x34 0xb9 | cut -c 3- | tr a-z A-Z) capacity=$(expr $(hex2dec $hex) - 128) if [ $capacity -ge 0 ] then echo $capacity > /sys/module/test_power/parameters/battery_capacity fi sleep 30 done
Press Ctrl+x and then y and press Enter to save it.

chmod +x /opt/axpd.sh
nano /etc/cron.d/axpd PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin @reboot root /opt/axpd.sh &
Press Ctrl+x and then y and press Enter to save it.

Conclusion

Having linux on Lenovo Miix 320 is not perfect, but for day-to-day usage (like browsing, office work, youtube), it's better than use the preinstalled Windows 10. After all we are moving things to the cloud.

Here are the list for things to be fix:

• Hard-click on the touchpad/clickpad
• Headphone jack insertion event (I still failed to probe it)
• Camera
• SD Card Slot