dweb | UCSC OSPO

Peersky Browser

Mon, 26 Jan 2026 12:00:00 -0800

Peersky Browser is an experimental personal gatekeeper to a new way of accessing web content. In a world where a handful of big companies control most of the internet, Peersky leverages distributed web technologies—IPFS, Hypercore, and BitTorrent return control to the users. With integrated local P2P applications, Peersky offers a fresh, community-driven approach to browsing.

Implement P2P Extension Store

Topics: Browser Extensions, P2P, Electron, IPFS, Hypercore
Skills: JavaScript, Electron.js, HTML/CSS, P2P
Difficulty: Moderate
Size: Medium (175 hours)
Mentors: Akhilesh Thite

Build a decentralized extension distribution flow that archives WebExtensions into a predictable P2P-friendly layout and installs directly from P2P URLs.

Tasks:

Define the P2P extension layout:
- Standardize /extensions/{name}/{version}/extension.zip and /extensions/{name}/index.json.
Design install compatibility for P2P URLs:
- Support peersky://extensions/... and P2P links from IPFS or Hypercore.
Archive Chrome Web Store extensions to P2P:
- Use chrome-extension-fetch to fetch CRX, convert to ZIP, and store it in the layout.
- Update index.json with metadata like version, P2P_URL, and fetchedAt.
- Publish the folder to IPFS or Hypercore and feed the link into the install flow.
Add settings and trust model:
- Add a “Load from P2P” settings toggle.
- Support curated extension hoards (index.json) and automated updates.
- Clarify integrity assumptions and sandboxing expectations.

More details in the issue: https://github.com/p2plabsxyz/peersky-browser/issues/42

Backup & Restore System (P2P JSON + Tabs Restore)

Topics: P2P, Backup, Session Restore, Electron, Onboarding
Skills: JavaScript, Electron.js, HTML/CSS, P2P
Difficulty: Moderate
Size: Medium (175 hours)
Mentors: Akhilesh Thite

Implement a backup and restore pipeline for Peersky’s P2P app data and session state, including an onboarding import flow for tabs from other browsers.

Tasks:

Generate a P2P backup bundle:
- Create a single .zip that contains lastOpened.json, tabs.json, ensCache.json, and the ipfs/ and hyper/ directories.
- Add an option to generate a CID for the backup zip for instant sharing.
Restore from settings:
- Upload a P2P backup zip file.
- Load a backup from an IPFS or Hyper CID.
- Import Chrome/Firefox tab exports produced by a helper extension.
Define the helper extension export format:
- Create a small extension under p2plabsxyz to export windows and tabs (URLs, titles, window grouping, active tab indexes).
- Ensure the export format is compatible with Peersky’s import pipeline.
Add onboarding import flow:
- Show onboarding.html on first launch and prompt “Import tabs from another browser?”.
- Guide users to install the helper extension and import the generated file.
Align with existing persistence:
- Reuse lastOpened.json, tabs.json, and peersky-browser-tabs localStorage for restores.

More details in the issue: https://github.com/p2plabsxyz/peersky-browser/issues/60

[Final] Building PeerSky’s Extensions System

Tue, 23 Sep 2025 00:00:00 +0000

Hi everyone, I’m Hanzhong Liu. Over the summer I worked on building the peersky://extensions system for PeerSky browser, a decentralized and privacy-first browser built on Electron.

This post is my final GSoC 2025 update — covering how the extensions manager was designed, the security model behind IPC, the UI for managing extensions, and what’s next for PeerSky.

Project Overview

The new extensions system makes PeerSky behave like a modern browser: you can install extensions from the Chrome Web Store or from local files, enable/disable them, update or uninstall, and interact with their toolbar actions through a puzzle-menu UI.

Key Design Goals

Secure preload-based API exposure via contextBridge
Support for preinstalled, Web Store, and local packages
Toolbar integration with pin/unpin support (up to six)
Robust validation: MV3-only, size caps, zip-slip prevention

Highlights

Preinstalled MV3s

PeerSky now ships with three trusted extensions out of the box:

Dark Reader
Linguist (web page translator)
uBlock Origin Lite

They remain installed by default but can be disabled at any time. This ensures users always have a working baseline without needing to browse an extension store.

Electron Integration

Instead of injecting scripts, the system uses preload + IPC. Each operation is routed through validated IPC channels:

listExtensions, installFromWebStore, toggleExtension, etc.
All methods are scoped to peersky://extensions only.
Rate limiting and size caps are enforced per renderer.

This design makes the surface auditable and prevents privilege leaks.

Browser actions appear in a puzzle menu and can be pinned for quick access:

Up to six pins are allowed
Pinned state persists across sessions.
Popups (e.g., for translators or wallets) open in isolated windows, with OAuth flows preserved via popup guards.

Security Highlights

Installs capped at 60 MB, with early rejection on oversized payloads
5 installs/minute per renderer to prevent abuse
ZIP/CRX extraction hardened against path traversal
MV3 required; permissions validated at install with warnings for risky hosts
Web Store installs use Google-signed CRX verification via electron-chrome-web-store

Example: Installing from the Web Store

Adding a new extension is simple:

Paste a Chrome Web Store URL or ID into the install bar.
PeerSky downloads and validates the CRX.
On success, the extension appears in the grid with toggle, update, and remove options.

Reflection

This project was both challenging and rewarding. Designing an extension system meant grappling with security, IPC design, and user experience at the same time. I learned to think carefully about security management, UI/UX positioning, and design APIs that are auditable.

I’m grateful to my mentor Akhilesh Thite and the UC OSPO team for their guidance and feedback. Their support pushed me to make deliberate technical decisions and communicate them clearly.

You can explore the project here: https://github.com/p2plabsxyz/peersky-browser

[MidTerm] Building PeerSky’s Settings System

Thu, 24 Jul 2025 00:00:00 +0000

Hi everyone, I’m Hanzhong Liu. My project focuses on building a secure and extensible peersky://settings system for the PeerSky browser, a decentralized and privacy-first browser built on Electron.

This post is a midterm check-in covering what’s been implemented so far — from IPC architecture to real-time theme and wallpaper updates — and a preview of what’s coming next.

Project Overview

Peersky’s new settings system is designed to unify browser preferences (themes, search engine, appearance, extensions, etc.) into a single modular interface. It’s accessible via a protocol route (peersky://settings) and built using web-standard HTML/CSS, scoped APIs, and Electron’s context isolation model.

Key Design Goals:

Secure preload-based API exposure via contextBridge
Fast access to user preferences with zero-flicker wallpaper updates
Extensibility for bookmarks, future plugins, and privacy tools

Midterm Progress Highlights

Electron Integration

Rather than using webFrame.executeJavaScript(), I implemented preload-scoped APIs using contextBridge and ipcRenderer to prevent injection vulnerabilities and ensure synchronous availability during early page load. Each internal protocol (settings, home, bookmarks) is granted its own API access level.

Code: src/pages/unified-preload.js

Modular Settings Page

The UI lives in a single HTML file with sidebar-based navigation (Appearance, Search, Bookmarks, Extensions). Each section updates independently using event-driven IPC and live sync.

Wallpaper & Theme Switching

Supports both built-in wallpapers and custom uploads
Background applies instantly using sendSync() during preload
Themes (light, dark, system) are controlled using root-level CSS variables and real-time IPC events

Cache & Search Engine

Added IPC handler to clear both Electron session and P2P cache directories (ipfs/, hyper/)
Settings API allows switching between DuckDuckGo, Ecosia, and Startpage via dropdown

Example: Adding a New Setting (`autoSave`)

I also documented how developers can add new settings like autoSave using:

settings-manager.js for default values and validation
Preload event listeners (onAutoSaveChanged)
UI toggles and save logic in settings.js

Documentation link: Settings Guide

Reflection

I’m really thankful for the mentorship I’ve received from Akhilesh Thite. His guidance has been the perfect balance of autonomy and support. He challenged me to reason clearly about technical choices, especially when I thought some of them are minor and not worthing paying attention to. His feedback helped me write cleaner, better-scoped code. This project has helped me grow as a software engineer in ways I didn’t fully anticipate, but I’ve enjoyed it so so much.

You can explore the project here:
https://github.com/p2plabsxyz/peersky-browser

Implement Web Extensions & System Settings Integration

Sun, 15 Jun 2025 00:00:00 +0000

Hi! I’m Hanzhong Liu, a Computer Science student at Fordham University with a minor in Business Administration. My interests lie in distributed systems, backend engineering, and decentralized tools—especially systems that prioritize user autonomy and privacy.

This summer, I’m contributing to the Peersky project as part of OSRE 2025 through Google Summer of Code. My project, “Implement Web Extensions & System Settings Integration,” will add full support for local browser extensions in Peersky, allowing users to customize their experience without relying on centralized extension stores.

Deliverables include an extension loader, drag-and-drop installation for .zip and Git-based extensions, manifest validation, sandboxing, and a unified peersky://settings page for managing everything from themes to privacy tools. Pre-installed extensions like uBlock Origin and DScan will be bundled by default.

You can read my full proposal here. My mentor for this project is Akhilesh Thite.

I’m excited to help build tools that empower users to take control of their browsing experience—and to contribute to the vision of a more decentralized web. Looking forward to the summer ahead!

Peersky Browser

Tue, 18 Feb 2025 12:00:00 -0800

Peersky Browser is an experimental personal gatekeeper to a new way of accessing web content. In a world where a handful of big companies control most of the internet, Peersky leverages distributed web technologies—IPFS, Hypercore, and Web3—to return control to the users. With integrated local P2P applications, Peersky offers a fresh, community-driven approach to browsing.

Implement Web Extensions Integration

Topics: Browser Extensions, UI/UX, Electron
Skills: JavaScript, Electron.js, HTML/CSS
Difficulty: Moderate
Size: Medium (175 hours)
Mentors: Akhilesh Thite

Implement web extension support in Electron by leveraging its web extension node modules, pre-installing extensions, and providing a user interface for adding, updating, and securely managing them.

Tasks:

Loading Extensions via Electron Modules:
- Utilize Electron’s web extension node modules to load extensions, as Electron.js doesn’t support marketplace integration.
Default Pre-installed Extensions:
- Configure a set of pre-installed extensions like uBlock to offer immediate value for privacy and security.
User-Installed Extensions UI:
- Create an interface where users can add extension .zip files in peersky://settings.
- Add an option for users to manually update all installed extensions.
Validate and Sandbox Extensions:
- Check the integrity and manifest structure of the uploaded extensions to ensure they meet Chrome Manifest V3 requirements.
- Apply sandboxing techniques and enforce strict content security policies to mitigate potential risks.
Extension Management UI:
- Design a dedicated UI at the top right of the navigation bar to manage extensions, including stack order and pinning functionality for quick access and organization.

Implement Chat History Synchronization for Hyper Chat Rooms

Topics: P2P Communication, Hypercore Protocol, Real-time Synchronization
Skills: JavaScript, Distributed Systems, P2P
Difficulty: Moderate
Size: Medium (175 hours)
Mentors: Akhilesh Thite

Implement chat history synchronization for Hyper chat rooms, ensuring that new devices retrieve all past messages—including those sent while offline—for a seamless user experience. Additionally, research and experiment with mDNS to enable true offline, peer-to-peer messaging on local networks.

Tasks:

History Retrieval Mechanism:
- Implement chat history synchronization so that when a new device joins a Hyper chat room, it retrieves the entire chat history from the Hypercore feed.
Offline Message Inclusion:
- Ensure that devices that were offline during prior messages can still access the full chat history upon joining the room, even after messages were sent in their absence.
UI Integration:
- Create a seamless experience for users across devices by ensuring that no messages are lost and that users can access the full chat history regardless of their online status.
Research mDNS (Multicast DNS):
- mDNS is a protocol that allows devices on the same local network to communicate with each other without the need for a central DNS server. This enables peer-to-peer communication, especially in offline environments, making it ideal for offline messaging.
- Experiment with the mDNS() function to enable peer-to-peer communication for offline chat rooms.
Create Hyper Chat Web App Version:
- Currently, Hyper chat is accessed via peersky://p2p/chat. Develop a web app version of Hyper chat that can be hosted on the hyper:// protocol (hyper://chat.p2plabs.xyz). This way, other P2P browsers (like Agregore) can use it to communicate.

dweb | UCSC OSPO

Peersky Browser

Implement P2P Extension Store

Backup & Restore System (P2P JSON + Tabs Restore)

[Final] Building PeerSky’s Extensions System

Project Overview

Key Design Goals

Highlights

Preinstalled MV3s

Electron Integration

Toolbar & Puzzle Menu

Security Highlights

Example: Installing from the Web Store

Reflection

[MidTerm] Building PeerSky’s Settings System

Project Overview

Key Design Goals:

Midterm Progress Highlights

Electron Integration

Modular Settings Page

Wallpaper & Theme Switching

Cache & Search Engine

Example: Adding a New Setting (autoSave)

Reflection

Implement Web Extensions & System Settings Integration

Peersky Browser

Implement Web Extensions Integration

Implement Chat History Synchronization for Hyper Chat Rooms

Example: Adding a New Setting (`autoSave`)