ArvinLovegood/go-stock: an AI stock analysis desktop app that keeps your data local

What go-stock actually solves for a retail A-share watcher

Most retail stock tooling splits into two camps. Broker terminals give you fast quotes and no interpretation. Chat interfaces give you interpretation with no data attached. go-stock sits between them: a desktop binary that fetches quotes, funds flow, tick-by-tick trades and market news, then hands those to a language model you configure. The README frames it as an AI-enabled analysis and stock-picking tool covering A-shares, Hong Kong and US markets, plus on-exchange ETF search, fund watchlists and fund rankings.

The audience is narrow and specific. It is someone who follows Chinese markets, already has an API key or a local model server, and wants the analysis step to happen without pasting numbers into a browser tab. The README is blunt about the intent: it says the project is for entertainment and that AI analysis results are for study and research only. That sentence matters more than any feature list, because it tells you the author does not treat the output as investment advice and neither should you.

The local-data promise is the other half of the pitch. The description states that all data is retained locally. For anyone uneasy about shipping their watchlist and holdings to a hosted analytics product, that is the reason to look at this repository rather than a web dashboard.

The Wails shell, the Go backend and where the model sits

go-stock is a Wails application, which means a Go process hosts a webview frontend built with NaiveUI. The repository layout confirms this: main.go, app.go, app_windows.go, app_darwin.go and app_linux.go sit at the top level, with backend/, frontend/ and a separate ai-assistant-web/ directory. Platform-specific app files exist for Windows, macOS and Linux, though the README states the development environment is mainly Windows 10 and that other platforms are untested or have limited functionality.

The AI layer is built on CloudWeGo Eino. The go.mod file lists eino itself plus provider components for Ark, Claude, DeepSeek, Gemini, Ollama, OpenAI, OpenRouter and Qwen, and an MCP tool component. That is the mechanism behind the long provider table in the README: each supported platform is an adapter into the same agent runtime, so switching from DeepSeek to a local Ollama model is a configuration change rather than a code change.

The README describes three agent modes (React, PlanExecute and DeepAgents), more than 150 AI data tools, a skill system, MCP extension support and a floating AI assistant. Treat the tool count as a description of surface area, not a quality signal. A large tool registry mainly tells you the model has many ways to query data, and more ways to query data also means more ways to query it badly.

On the data side, go.mod pulls in github.com/bensema/gotdx, a Go implementation of the TDX protocol, which suggests TDX is one of the quote sources. The dependency list also includes chromedp, which suggests some news or page scraping runs through a headless browser. That is a fragile ingestion path by nature: when a page layout changes, the scrape breaks and the app may not tell you.

Installing go-stock and getting one real analysis out of it

For end users, the README points to prebuilt binaries on the releases page: a green (portable) Windows build named go-stock-windows-amd64.exe and a macOS universal build named go-stock-darwin-universal. Download the one for your platform and run it; there is no installer step documented for the current release line.

If you want to build from source, the repository is a standard Go module named go-stock requiring Go 1.27.2, with a Wails frontend. The repository has a wails.json; check docs/go-stock使用手册.md before assuming a build flag or task name.

After launch, the first useful step is binding a model. The README's provider table lists DeepSeek with the model names deepseek-reasoner and deepseek-chat, and notes that any OpenAI-compatible endpoint works. Configure the endpoint and key in the app's settings page; the README links a separate guide to that page (docs/小白设置页面使用说明.md).

Once a model responds, add a symbol to the watchlist and open its detail view. The README lists K-line analysis with adjustment switching, Elliott wave theory, measurement boxes and 13 drawing tools, plus intraday and tick data, call auction and per-stock funds flow. Ask the floating assistant a question about the selected symbol and you should get an answer grounded in those panels. If the reply is generic, the model is probably not receiving tool output, which usually means the endpoint is wrong or the model does not support the tool-calling format the agent expects.

For alerts, the README lists scheduled warnings with Feishu or DingTalk push.

Where go-stock breaks, and the cases it is the wrong tool for

The clearest limitation is stated by the author: the development environment is Windows 10, and other platforms are untested or limited. Top-level files for Darwin and Linux exist, and update_helper_darwin.go and update_helper_linux.go are present, so cross-platform work has started. But a file existing is not the same as a tested path, and a macOS or Linux user should expect rough edges rather than parity.

The second limitation is the model dependency. Every AI feature is only as good as the endpoint you bind. A small local model will produce confident, fluent, wrong analysis of a funds-flow table, and nothing in the pipeline will flag that. The README's own disclaimer that results are for study and research is the honest version of this problem.

The third is ingestion fragility. A TDX-based quote path and a chromedp-based scraping path both depend on external services and page structures you do not control. When a source changes, the failure mode is often missing or stale data rather than a loud error, and stale data fed to a language model still produces a tidy paragraph.

Finally, this is a desktop GUI application. If you want a scheduled job that writes analysis to a database, or an API other services can call, go-stock is the wrong shape. The Wails architecture assumes a window.

go-stock versus a scripted Python pipeline

The obvious alternative for a developer is a Python stack: a data library for quotes, a scheduler, and direct calls to the same model APIs. The difference is not the model, since both can hit DeepSeek or a local Ollama server. The difference is where the work lives.

A scripted pipeline gives you version control over the analysis logic, tests, and a diffable record of what changed between runs. go-stock gives you a graphical workspace where the K-line tools, funds-flow panels, news aggregation, dragon-tiger list, limit-up ladder and alerting are already assembled, and where the AI sees structured tool output instead of whatever you remembered to serialize. For someone who does not want to maintain a scraper, that is a real saving.

The cost is transparency. In a script you can read the prompt and the data payload. In go-stock the agent decides which of its 150-plus tools to call. If you need to explain why a conclusion was reached, the scripted route is easier to defend, and go-stock is easier to start.

Maintenance, release cadence and the GPL-3.0 boundary

The repository is not archived and the last push was on 2026-10-31. The three newest releases landed within a week: v2026.10.31.1-release, v2026.10.27.1-release and v2026.10.26.1-release. The README tells users to prefer the newest published version because the software is under rapid iteration. That cadence cuts both ways. You get fixes quickly, and you also get churn, so keeping the previous binary around is a practical upgrade strategy.

The dependency graph is heavy. go.mod pins Eino and eight model adapters, chromedp, gotdx, gse for Chinese text segmentation, beeep and go-toast for notifications, and an auto-update library. One detail worth knowing: the module replaces github.com/mattn/go-sqlite3 with a stub under third_party/mattn-sqlite3-stub so the build stays pure Go and uses modernc.org/sqlite instead. That is a deliberate choice to avoid CGO, and it means a from-source build does not need a C toolchain for SQLite.

The licence is GPL-3.0. If you fork go-stock and distribute a modified binary, the GPL's copyleft terms apply to that distribution, and the repository ships a LICENSE file you should read rather than rely on this summary. Running it privately for your own research does not trigger distribution obligations in the usual reading, but if you plan to embed it in a product, have a lawyer look at the combination of GPL-3.0 and any model provider terms. This is not legal advice.

Editorial conclusion

Adopt go-stock if you already run a local model through Ollama or LMStudio, want A-share, Hong Kong and US quotes in one desktop window, and accept that the output is study material rather than a signal. Skip it if you need a headless service, a tested macOS or Linux build, or an auditable analysis pipeline, because the README states the development environment is Windows 10 and other platforms are untested or limited. Before trusting a single number, open the settings panel and confirm which model endpoint is bound, then check whether the quote source for your market is reachable from your network, since a silent model or feed failure produces plausible-looking output rather than an error.

Frequently asked questions

Official sources

1. ArvinLovegood/go-stock on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases