wrp - GitLite

KO | EN

gitlite — search

#python #react #ai #llm #rust #linux #java #awesome #vue #pytorch #security #mcp #openai #open-source

wrp

(★ 1,277)

Web Rendering Proxy: Use vintage, historical, legacy browsers on modern web

파일 탐색기

최종 버전 다운로드 (.zip)

.gitignore
.goreleaser.yml
Dockerfile
Dockerfile.goreleaser
Dockerfile.local
download.go
go.mod
go.sum
ismap.go
LICENSE
Makefile
popup.go
popup_test.go
README.md
session.go
shtml.go
util.go
vnc.go
vncbrowser_test.go
vncenc.go
vncenc_test.go
vncproto_test.go
vncstall_test.go
wrp.go
wrp.html
wrp.png

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/tenox7/wrp

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd wrp

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Docker

쉬움 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Docker Desktop 컨테이너를 빌드하고 실행하려면 필요합니다. 설치 후 실행해서 백그라운드에 켜두세요.

$ docker run -d --rm -p 8080:8080 tenox7/wrp:latest

빌드된 이미지를 실제 컨테이너로 실행합니다.

✅ 터미널에 docker compose ps 를 입력해 컨테이너들이 Up 상태인지 확인하세요. README에 포트 번호가 적혀있다면 브라우저에서 http://localhost:포트번호 로 접속해보세요.

이 레포의 README에 적힌 실제 명령어를 그대로 가져왔습니다.

3. Go

보통

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Go Go 언어 컴파일러 및 도구 모음입니다.

go build ./...

Go 프로그램을 컴파일해 실행 파일을 만듭니다.

go run .

따로 빌드하지 않고 바로 Go 프로그램을 실행합니다.

✅ 빌드가 에러 없이 끝나면 성공입니다. go run . 을 썼다면 터미널 출력을 확인하세요.

4. Make

보통

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Make Linux/macOS는 보통 기본 설치되어 있습니다. Windows는 별도 설치(예: MSYS2, WSL)가 필요합니다.

make

생성된 빌드 설정을 바탕으로 실제 컴파일을 진행해 실행 파일을 만듭니다.

✅ 에러 없이 끝나면 성공입니다. 생성된 실행 파일을 직접 실행해보세요.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# WRP - Web Rendering Proxy

A browser-in-browser proxy server that allows to use historical / vintage web browsers on the modern web.

![Internet Explorer 1.5 doing Gmail](https://raw.githubusercontent.com/tenox7/wrp/master/wrp.png)

## Modes of operation

### Access Types

- Browser-in-browser, navigate to the address of WRP and use the built-in web form to browse web.
- HTTP proxy mode which offers more seamless, but also limited use. Semi compatible with https://.

### Rende modes

- ISMAP "graphical" mode, renders web page in to a GIF/PNG/JPG image with clickable imagemap.
- Simple HTML mode converts pages into simplified HTML for old browsers.

Different modes have different uses. ISMAP mode will be better for flashy modern web. Simple HTML mode will be better for reading articles or documentation.

## Usage Instructions

* [Download a WRP binary](https://github.com/tenox7/wrp/releases/) run it on a machine that will become your WRP gateway/server. This should be modern hardware and OS. Google Chrome / Chromium / Brave Browser is required to be preinstalled. Do not run WRP on an old machine like Windows XP or 98.
* Make sure you have disabled firewall or open port WRP is listening on (by default 8080).
* Point your legacy browser to `http://address:port` of the WRP server or set your proxy address there. 
* Type a search string or a full http/https URL and click **Go**.
* Select whether you want to use graphical (ISMAP) or simple HTML mode.

### Proxy mode

- You can use `/proxy.pac` automatic configuration mode.
- Stick to `http://` addresses only, the proxy will automatically rewrite them to `https://` as needed.
- `https://` addresses are limited in functionality (no /suffix or paths).
- Proxy mode doesn't have a customizable web interface with html forms. All configuration is done via flags.

### Image Map Mode

* Adjust your screen **W**idth/**H**eight/**S**cale/**C**olors to fit in your old browser.
* Scroll web page by clicking on the in-image scroll bar on the right.
* WRP also allows **a single tall image without the vertical scrollbar** and use client scrolling. To enable this, simply height **H** to `0` (or flag `-g 1152x0x216`. However this should not be used with old and low spec clients. Such tall images will be very large, take a lot of memory and long time to process, especially for GIFs.
* Do not use client browser history-back, instead use **Bk** button in the app.
* You can re-capture screenshot without reloading page by using **St** (Stop). This is useful if page didn't render fully before screenshot is taken.
* You can also reload page and re-capture screenshot with **Re** (Reload).
* To send keystrokes, fill **K** input box and press **Go**. There also are buttons for backspace, enter and arrow keys.
* The default image type is `GIP` - an ultra fast, optimized, parallel encoded GIF type.
* If your browser supports it, prefer PNG over GIF/JPG. PNG is much faster, whereas GIF/JPG requires a lot of additional processing on both client and server to compress/uncompress.
* GIF images are by default encoded with 216 colors, "web safe" palette. This uses an ultra fast encoding algorithm optimized mostly for text. Images have rather wonky color colors. If you want better color representation switch to 256 color mode.

### Simple HTML mode

* Select image type PNG/GIF/JPG. Each individual image from the original web site will be converted to the selected format.
* Type maximum image size in pixels.

## UI explanation

The first unnamed input box is either search (google) or URL starting with http/https

`Go` Navigate to the url or perform search

`Bk` History Back

`St` Stop, also re-capture screenshot without refreshing page, for example if page
render takes a long time or it updates / changes periodically

`Re` Remote Reload / Refresh

`Up` Page Up

`Dn` Page Down

`W` is width in pixels, adjust it to get rid of horizontal scroll bar

`H` is height in pixels, adjust it to get rid of vertical scroll bar.
It can also be set to 0 to produce one very tall image and use
client scroll. This 0 size is experimental, buggy and should be
used with PNG and lots of memory on a client side.

`Z` Zoom or scale

`M` Mode - ISMAP (clickable imagemap) or simple HTML mode

`T` Image type PNG / GIF / JPEG

`C` Colors, for GIF images only

`K` Keystroke input, you can type some letters in it and when you click Go it will be typed in the remote browser.

`Bs` Backspace

`Rt` Return / enter

### UI Customization

WRP supports customizing it's own UI using HTML Template file. Download [wrp.html](wrp.html) place in the same directory with wrp binary customize it to your liking.

## Docker

https://hub.docker.com/r/tenox7/wrp

```shell
$ docker run -d --rm -p 8080:8080 tenox7/wrp:latest
```

## AWS

It's possible to run WRP on AWS App Runner.

First you need to upload the Docker image to ECR - [Instructions](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html).

Create App Runner service using the uploaded image using the AWS Console or CLI.

[AWS Console](https://console.aws.amazon.com/apprunner/home#/create)

```shell
aws apprunner create-service --service-name my-app-runner-service --source-configuration '{
    "ImageRepository": {
        "ImageIdentifier": "<account_id>.dkr.ecr.<region>.amazonaws.com/wrp:latest",
        "ImageRepositoryType": "ECR",
        "ImageConfiguration": {"Port": "8000"},
        "AutoDeploymentsEnabled": true
    }
}' --instance-configuration '{
    "Cpu": "1024",
    "Memory": "2048",
    "InstanceRoleArn": "arn:aws:iam::<account_id>:role/AppRunnerECRAccessRole"
}'
```

## Azure Container Instances

[Azure Console](https://portal.azure.com/#create/Microsoft.ContainerInstances)

CLI:

```shell
$ az container create --resource-group wrp --name wrp --image tenox7/wrp:latest --cpu 1 --memory 2 --ports 80 --protocol tcp --os-type Linux --ip-address Public --command-line '/wrp -l :80 -t png -g 1280x0x256'
```

## Google Cloud Run

```shell
$ gcloud run deploy --platform managed --image=tenox7/wrp:latest --memory=2Gi --args='-t=png','-g=1280x0x256'
```

Unfortunately Google Cloud Run forces you to use HTTPS, which likely won't work with old browsers.

## Flags

```text
-l   listen address:port (default :8080)
-m   mode, either ismap (graphical) or html
-t   image type gif, png or jpg (default gif)
-g   image geometry, WxHxC, height can be 0 for unlimited (default 1152x600x216)
     C (number of colors) is only used for GIF
-q   Jpeg image quality, default 75%
-h   headless mode, hide browser window on the server (default true)
-n   do not free maps and images after use (default false)
-ui  html template file (default "wrp.html")
-ua  user agent, override the default "headless" agent (only for ismap mode)
-s   delay/sleep after page is rendered before screenshot is taken (default 2s)
-b   browser executable path (e.g., for Brave Browser)
-profile  Chrome user-data dir, persists cookies/logins and the session between runs
```

## Minimal Requirements

* Server/Gateway requires modern hardware and operating system that is supported by [Go language](https://github.com/golang/go/wiki/MinimumRequirements) and Chrome/Chromium Browser, which must be installed.
* Client Browser needs to support `HTML FORMs` and `ISMAP`. Typically [Mosaic 2.0](http://www.ncsa.illinois.edu/enabling/mosaic/versions) would be minimum version for forms. However ISMAP was supported since 0.6B, so if you manually enter url using `?url=...`, you can use the earlier version.

## FAQ

### I can't get it to run

This program does not have a GUI and is run from the command line. After downloading, you may need to enable executable bit on Unix systems, for example:

```shell
$ cd ~/Downloads
$ chmod +x wrp-amd64-macos
$ ./wrp-amd64-macos
```

### Pages are chopped off

Click `st` to re-capture screenshot. You may want to increase the page delay using `-s` flag.

### Websites are blocking headless browsers

This is a well known issue. WRP has some provisions to work around it, but it's a cat and mouse game. By default WRP tries to obtain some current valid User Agent from https://github.com/jnrbsn/user-agents rather than using the internal "HeadlessChrome". You can override this to your own, for example:

```shell
$ wrp -ua="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"
```

### Staying logged in to Gmail and other sites

Use `-profile ~/.wrp-chrome` to persist cookies/logins between runs. Log in once with `-h=false`, then restart headless. Run WRP on the same machine you logged in on (the cookie key lives in the OS keychain).

### Saving and restoring the session

With `-profile` WRP also remembers the session in `wrp-session.json` inside the profile dir and restores it on the next run: image geometry, zoom, image type, colors, quality and mode for the ISMAP/HTML UI, the VNC framebuffer size and zoom, plus the open tabs, which are reopened where you left off. Flags given on the command line always win, for example `-g 1024x768x256` overrides the saved geometry and `-vncpage` skips reopening tabs.

### Why isn't there a Docker image for armv6

Because https://hub.docker.com/r/chromedp/headless-shell/ doesn't have one. WRP uses that image. If you have a fork that builds for armv6 let me know.

### WTF is GIP image format

It's just GIF but optimized. Avoids dithering, uses fast color palette and parallel encoding. https://github.com/tenox7/gip

## History

* Version 1.0 (2014) started as a *cgi-bin* script, adaptation of `webkit2png.py` and `pcidade.py`, [blog post](https://virtuallyfun.com/2014/03/03/surfing-modern-web-with-ancient-browsers/).
* Version 2.0 became a stand alone http-proxy server, supporting both Linux and MacOS, [another post](https://virtuallyfun.com/wordpress/2014/03/11/web-rendering-proxy-update//).
* In 2016 thanks to [Let's Encrypt](https://en.wikipedia.org/wiki/Let%27s_Encrypt) the whole internet migrated to HTTPS/SSL/TLS and WRP largely stopped working. Python code became unmaintainable and there was no easy way to make it work on Windows, even under WSL.
* Version 3.0 (2019) has been rewritten in [Go](https://golang.org/) using [Chromedp](https://github.com/chromedp) as browser-in-browser instead of http-proxy. The initial version was [less than 100 lines of code](https://gist.github.com/tenox7/b0f03c039b0a8b67f6c1bf47e2dd0df0).
* Version 4.0 has been completely refactored to use mouse clicks via imagemap instead parsing a href nodes.
* Version 4.1 added sending keystrokes in to input boxes. You can now login to Gmail. Also now runs as a Docker container and on Cloud Run/Azure Containers.
* Version 4.5 introduces rendering whole pages in to a single tall image with client scrolling.
* Version 4.6 adds blazing fast gif encoding by [Hill Ma](https://github.com/mahiuchun).
* Version 4.6.3 adds arm64 / aarch64 Docker container support - you can run it on Raspberry PI!
* Version 4.7 add simple html aka reader aka text mode.
* Version 4.8 add image support to simple html mode.
* Version 4.9 adds support for ultra fast, parallel encoded gif image (GIP)
* Version 4.10 re-adds support for http proxy mode

## Credits

* Uses [chromedp](https://github.com/chromedp), thanks to [mvdan](https://github.com/mvdan) for dealing with my issues
* Uses [go-quantize](https://github.com/ericpauley/go-quantize), thanks to [ericpauley](https://github.com/ericpauley) for developing the missing go quantizer
* Thanks to Jason Stevens of [Fun With Virtualization](https://virtuallyfun.com/) for graciously hosting my rumblings
* Thanks to [claunia](https://github.com/claunia/) for help with the Python/Webkit version in the past
* Thanks to [Hill Ma](https://github.com/mahiuchun) for ultra fast gif encoding algorithm
* Historical Python/Webkit versions and prior art can be seen in [wrp-old](https://github.com/tenox7/wrp-old) repo

## Related

You may also be interested in:

* [VncFox](https://github.com/tenox7/vncfox)
* [webone](https://github.com/atauenis/webone)
* [Pici Server](https://github.com/picidae-project/pici-server)
* [Browservice](https://github.com/ttalvitie/browservice)
* [Browsh](https://github.com/browsh-org/browsh)

## Legal Stuff

```text
License: Apache 2.0
Copyright (c) 2013-2026 Antoni Sawicki
```