[BRLTTY] Is there a feature-compatible text-based browser

[Nicolas Pitre]

On Tue, 16 Sep 2025, kperry at blinksoft.com wrote:

> Instead of trying to maintain a stand-alone text browser like Lynx, wouldn't
> it be easier to build a command-line browser that uses a modern engine like
> Chrome or Firefox as the backend? You'd only need some X libraries
> installed, but not an actual running desktop. Interaction could be handled
> through text, while the backend stays updated automatically as Chrome or
> Firefox updates.

Well well...

I wanted to have something more functional and stable before I post it 
here ... but here's the README as a teaser for the project I'm working 
on when time permits. There are still many issues and bugs, but I was 
able to log into my Facebook account, even with MFA active, for the 
first time using a text-based interface. I didn't publish the code yet 
but I'm willing to share with people with development skills eager to 
contribute (this is not ready for casual user yet).

=====

# Firelynx: Where Firefox Meets lynx

⚠️ **EXPERIMENTAL ALPHA SOFTWARE** - Firelynx is in early development. 
While functional for many websites, expect bugs, limitations, and breaking 
changes. Use at your own risk and keep backups of important work.

The web has moved on, but accessible browsing hasn't kept up.
Firelynx changes that by creating a bridge between the excellent
accessibility of lynx and the modern web compatibility of Firefox.

## The Problem: When the Web Left Accessibility Behind

If you're a blind user, you know the frustration. Traditional text browsers
like lynx work beautifully with braille displays and screen readers - they're
fast, efficient, and give you exactly the semantic information you need.
But try to use Google Search, Facebook, or most modern websites, and you're
out of luck. These sites require JavaScript to function, leaving lynx users
stuck with broken layouts, completely blank pages, or worse - some sites
simply refuse to serve you if your browser isn't one of the big ones.

On the other hand, Firefox is a powerhouse that handles any modern website
perfectly. But running Firefox in a GUI environment when you're using a
braille display is like using a sledgehammer to crack a nut. You're forced
to navigate through complex visual interfaces, deal with mouse-centric
designs, and lose the clean, efficient text-based interaction that makes
computing accessible in the first place.

### What About term.everything?

You might have heard of [term.everything](https://github.com/mmulet/term.everything) - 
a project that promises to render GUI applications in the terminal as ASCII 
art. Sounds perfect, right? Unfortunately, it doesn't solve our problem at 
all. 

When term.everything displays Firefox, you get something like this:
```
🬽 ▀▀▀▀▀▀🬼   ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
˛🬠▂▂▂   ▌ ┃    🬼                                            ▎
```

This is just visual noise to a braille display. There's no semantic 
structure, no way to understand what's a heading versus a link versus body 
text. It's graphics made of text characters - completely inaccessible to 
the tools that blind users rely on.

## The Solution: Firelynx

The breakthrough came from realizing we didn't need to choose between lynx 
and Firefox. What if we could use Firefox as a backend engine to process 
modern websites, then serve the results through lynx's familiar, 
accessible interface?

That's exactly what Firelynx does. It creates an HTTP proxy server that 
sits between lynx and the web. When you browse with lynx, the proxy 
intercepts your requests, processes them through a headless Firefox 
instance (complete with JavaScript execution), extracts the meaningful 
content, and serves it back to lynx as clean, semantic HTML.

The result? You get to keep lynx's excellent accessibility - all your
customizations, keyboard shortcuts, and the clean interface that works
perfectly with your braille display in a text-based terminal with
[BRLTTY](http://brltty.app/) - while gaining access to any modern website
that Firefox can handle.

## Features That Make It Work

**Modern Web Compatibility**: Google Search, Facebook, complex JavaScript 
sites - they all work because Firefox handles the heavy lifting.

**Seamless lynx Experience**: Every lynx feature works exactly as before. 
Your muscle memory, customizations, and workflow remain unchanged.

**Smart Content Extraction**: The system intelligently finds and
prioritizes main content while filtering out navigation clutter and ads.

**Runtime Content Filtering**: Choose your preferred balance between showing
everything (bridge mode) and clean reading (filtered mode) with instant
switching between filter levels.

## Installation

### Fedora Linux
```bash
# Install the packages
sudo dnf install python3-selenium selenium-manager firefox lynx

# Get and install Firelynx
git clone [your-repo-url] firelynx
cd firelynx/
./install.sh

# Now you can use 'firelynx' from anywhere
firelynx https://example.com
```

### Debian/Ubuntu
```bash
# Install the packages  
sudo apt update
sudo apt install python3-selenium firefox lynx

# Note: No additional geckodriver installation needed!
# Modern Selenium (4.x+) automatically downloads geckodriver on first use

# Get and install Firelynx
git clone [your-repo-url] firelynx  
cd firelynx/
./install.sh

# Now you can use 'firelynx' from anywhere
firelynx https://example.com
```

## How to Use

**Start browsing any website:**
```bash
firelynx https://facebook.com
firelynx google.com  
firelynx
```

This launches lynx connected to the Firefox proxy. Navigate exactly as you 
normally would in lynx - press 'g' to go to URLs, follow links normally, 
fill out forms as usual. You now have a much greater chance for 
JavaScript-heavy sites to work to some extent.

**For quick text output without interactive lynx:**
```bash
firelynx --dump --search "python tutorial"
firelynx --dump https://example.com
firelynx --dump --search "weather forecast" --engine bing
```

## Current Limitations

**JavaScript Modal Dialogs**: Some modal dialogs (like Facebook's device 
trust prompts) don't convert properly yet. The detection system is there 
but needs refinement.

**Google Search CAPTCHAs**: Google still detects the automation and shows 
robot verification. Use DuckDuckGo instead - it works perfectly and doesn't 
have this issue.

**MFA Timing**: On sites like Facebook, if you press the "continue" button 
too quickly during multi-factor authentication, you might not get the 
expected retry prompts.

**Some False Positives**: Occasionally sites like Amazon trigger MFA 
warnings when no authentication is actually required.

Despite these quirks, the browser handles many websites well, including
complex authentication flows, form submissions, and JavaScript-heavy content
that traditional text browsers simply can't access.