Inside SPLOOM, the stock market terminal built for the Sony PSP

A Sony PSP displaying live stock prices sounds like the sort of thing someone builds for a quick technical joke. SPLOOM goes much further. This homebrew project turns the handheld into a working financial terminal with portfolio data, market information, price charts, news summaries and paper-trading controls. It doesn’t simply load a website or stream a desktop screen. The software was built around the PSP’s hardware limits from the start. That matters, because the PSP wasn’t designed for modern financial platforms. It has very little memory, an ageing processor, a small display and none of the software libraries developers now take for granted. So the project takes a smarter route. The PSP handles the interface. A separate Python server handles the heavy work.

Built around a 24 MB memory limit

The biggest problem is memory. The PSP gives the application roughly 24 MB to work with, which disappears quickly when software starts downloading large financial datasets. Modern market APIs usually return JSON files packed with nested fields, timestamps, metadata and values the screen will never display. A laptop can process all that without breaking a sweat. The PSP can’t.

Trying to parse those responses directly on the handheld would make the application slow, fragile or both. It could also run out of memory. SPLOOM avoids that problem by using a Flask server as a middle layer. The server contacts market-data services, brokerage systems and news providers. It then pulls out the useful information, calculates any required indicators and sends the PSP a much smaller response.

The handheld receives simple lines of text instead of complex data structures. That’s the clever part. The PSP doesn’t need to understand how each external service works. It doesn’t need a full JSON parser, financial libraries or complicated authentication code. It only needs to request data, split the response into sections and draw the results on screen. Simple works better here.

Five screens cover the main financial tools

SPLOOM organises its interface into five sections: Main, Markets, Chart, News and Order. You move between them using the PSP’s physical controls. There’s no touchscreen, mouse or keyboard, so every part of the interface has to work with a D-pad and a few buttons.

The Main screen acts as the portfolio overview. It shows account value, available buying power, current holdings, unrealised gains or losses, portfolio allocation and open orders. That’s the information most users would check first.

The Markets section focuses on individual companies and securities. It displays current price information alongside figures such as earnings per share, dividend yield, market capitalisation, beta, price-to-earnings ratio and price-to-book ratio.

These numbers usually appear inside large desktop dashboards. Here, they’ve been cut down and arranged for a 480 × 272-pixel screen. The result isn’t flashy. It’s readable. SPLOOM uses a dark terminal-style layout with fixed-width text and clear colour changes for gains, losses and status information. The design fits the hardware instead of pretending the PSP is a miniature smartphone.

The chart screen does real work

The Chart screen is one of the project’s more technically interesting features. Historical price data can contain hundreds or thousands of points. Sending all of them to the PSP would waste memory and network bandwidth, so the server reduces the dataset before transmission. The final chart uses no more than 100 points.

The server also normalises the values, which makes it easier for the PSP to draw the data within the available screen space. The handheld receives a compact set of coordinates and renders the chart itself.

These aren’t screenshots or pre-made images. The graphics are drawn on the PSP. Users can view several time periods, from a single day to multi-year ranges. The chart can also display a 20-period simple moving average and Bollinger Bands. That gives the feature more depth than a basic price line. Of course, nobody will confuse it with a professional Bloomberg terminal. That isn’t the point. The impressive part is that technical charting works at all on hardware this limited.

News gets trimmed before reaching the PSP

Financial news creates another problem. Headlines are manageable, but summaries can be long, badly formatted or filled with characters the PSP can’t display correctly. SPLOOM cleans the text on the server.

Unsupported characters are removed or replaced. Long descriptions are shortened to fit the available memory. Where possible, the server cuts the text at the end of a complete sentence instead of stopping halfway through a word. It’s a small detail, but it makes the news screen feel finished.

The server also runs sentiment analysis on each item and labels it as bullish, bearish or neutral. That gives users a quick way to scan a list of stories before opening a longer summary. These labels shouldn’t be treated as financial advice. They’re automated indicators based on language, not a deep reading of the company or market. Still, they suit the screen. The PSP has very little room, so every symbol and label needs to earn its place.

You can place paper trades with the D-pad

SPLOOM isn’t limited to reading data. It also includes an order-entry screen. Users can select a stock symbol, choose whether to buy or sell, enter a quantity or monetary amount, select an order type and set the time-in-force option. All of this happens through the PSP controls. Orders are then sent to the server, which passes them to a brokerage API.

By default, the system uses paper trading. That means it works with simulated money instead of a live brokerage balance. That’s the right choice. This is experimental software running on a handheld released more than two decades ago. Paper trading lets the order workflow function without putting real funds at risk. The application can also display active orders and refresh their status. That turns the Order screen into more than a static form. It behaves like a compact trading blotter.

The PSP client stays deliberately simple

The handheld side of SPLOOM is written in C using the PSP development toolchain. It handles controller input, networking, text placement, screen updates and basic graphics. The code relies on fixed buffer sizes and carefully controlled responses because dynamic memory use can become risky on this hardware. Even basic web communication needs extra attention.

HTTP responses often contain carriage returns, line feeds and formatting that desktop software handles automatically. On the PSP, those characters can affect how text appears on screen. SPLOOM cleans the incoming data before displaying it.

The application also works around the PSP debug-screen system, which doesn’t provide the sort of transparent interface layers modern developers expect. Instead, it uses solid backgrounds, fixed positioning and direct colour changes. Nothing is wasted.

The server makes the whole project possible

The Python backend does much more than fetch stock prices. It handles authentication, contacts external services, parses JSON, calculates chart indicators, shortens news text, analyses sentiment and formats everything into a lightweight protocol the PSP can understand. Without that server, the project would be much harder to build and far less reliable.

This split also makes the system easier to update. If a market-data service changes its API, most of the repair work can happen on the server. The PSP application doesn’t need to know where the information came from or how the original response was structured.

It just expects the same compact format. That’s a practical architecture, not a workaround.

A serious systems project in an unusual package

Most people won’t use a PSP to check their portfolio. A phone can do it faster, with stronger security and better support. SPLOOM doesn’t need to compete with those devices.

Its value comes from the way it handles constraints. The project takes a machine with little memory, limited networking and a small display, then gives it access to modern financial services without overwhelming it. The handheld does what it’s good at: buttons, text, simple graphics and direct interaction.

The server handles everything else. That separation is what makes SPLOOM convincing. It isn’t just a stock ticker running on old hardware. It’s a carefully designed client-and-server system that turns the PSP into a usable market terminal, one compact response at a time.