From Chat to Colleague

✨ From just a Chatbot to Being your Colleague

"Give Solaris a file, and let's work with it."

This release turns Solaris from a pure chat assistant into something that can actually read your files and see your pictures.

---

📎 File Attachments

Solaris can now read files you drop into the conversation. One .ATTACH and the file becomes part of the session's context — something Solaris can quote from, reason over, and build answers from.

.ATTACH /Users/you/Desktop/class_notes.md
.ATTACH /Users/you/Desktop/report.pdf
.ATTACH /Users/you/Desktop/screenshot.png

What each type is good for:

Type	What Solaris does with it
.md	Reads the full text, word for word — great for notes, skill files, preferences, task briefs
.pdf	Extracts text page by page — reports, textbooks, assignments (as long as they have real text)
.jpg .jpeg .png	Validates the image and reads its metadata — ready for .VISION

Deliberately temporary. Attachments live for the session and disappear when you close the chat. No database writes, no long-term memory pollution. If you didn't ask to keep it, Solaris doesn't — so your permanent memory stays clean and about you, not about random files you happened to open.

🗑️ Detachments

Changed your mind — or made a mistake? .DETACH puts every current attachment in a numbered table and lets you remove exactly the one you don't want.

.ATTACH a.md
.ATTACH b.pdf
.ATTACH c.jpg

.DETACH
# ┌── Attached Files ──────┐
# │ #  │ File Path         │
# ├────┼───────────────────┤
# │ 1  │ a.md              │
# │ 2  │ b.pdf             │
# │ 3  │ c.jpg             │
# └────┴───────────────────┘
# → Serial number: 2
# → Removed attachment: b.pdf

Clean removal, honest feedback, and the rest of your session context is untouched. You stay in control of exactly what Solaris is "holding" at any moment.

✨ .BETTER, now context-aware & personal

.BETTER was already your best-answer-on-demand — but it asked blind. Now it knows your files.

You choose what matters. Before anything happens, Solaris shows your attached files and asks which ones .BETTER should take into account:

.ATTACH ~/Desktop/physics_notes.md
.ATTACH ~/Desktop/homework.pdf
.BETTER help me with today's task

# → shows: 1. physics_notes.md   2. homework.pdf
# → How many files to use? 2
# → Pick: 1, 2

Smarter questions for your level. .BETTER doesn't just dump an answer — it interviews you first through the Strategist. And it now shapes those questions around your files: attach your own class notes on a topic, and the questions adapt to your notes, your phrasing, your level of detail — instead of generic textbook questions that assume nothing about you. It can ask about the exact concept you highlighted, clarify the part you're stuck on, and zoom in on your specific task instead of the topic in general.

Specialists that see what you see. The Writer, Programmer, and Strategist all read the files you selected, so their answers are grounded in your actual material — your notes, your code, your task brief — not a guess about what you meant. No more "here's a generic essay" when you handed it your own draft.

Zero friction when you don't need it. One file attached? It's used automatically, no prompts. No files? .BETTER works exactly as before — nothing broke, everything gained.

👁️ .VISION — image analysis

The showstopper. Attach an image, then ask a question about it — and Solaris actually looks.

.ATTACH ~/Desktop/screenshot.png
.VISION what's wrong with this error message?

.ATTACH ~/Desktop/quiz_diagram.jpg
.VISION explain what this diagram is showing

Two capable eyes behind it. Primary is Kimi-K3; if that fails, Solaris silently falls back to Llama-3.2-90B-Vision — both powered by NVIDIA NIM. You never see the plumbing; you just get an answer. As always, If you desire to switch to a model of your preference, You can do it by just updating the config.json file, and writing your preferred model and provider's name there!

Built for real workflows, not demos:

• Multiple images — attach several and it considers them together ("compare these two")
• One image, zero friction — a single attachment is used instantly, no picker
• Smart model handling — it knows Llama's per-request limit and adapts automatically
• Configurable — the models live in config.json, so you can swap in another vision model anytime without touching code
• Honest when unsure — the prompt tells it to say so when an image is unclear, rather than inventing details

Every call is logged to System_Logs.txt, so if something goes wrong, you've got a paper trail.

🔎 .WEB — Web Search

The promise that's been sitting in .HELP since v1.1.0 as "WIP" finally has an engine behind it.

.WEB india's next cricket match
.WEB:quick coffee filter experiment
.WEB:deep quantum computing explained for beginners

Depth you control. Search isn't a one-size box anymore — you pick how thorough Solaris should be:

Syntax	Results	When to use it
.WEB:quick <q>	3 sources	Fast check — facts, status, quick lookups
.WEB <q>	5 sources	Everyday research, balanced speed vs breadth
.WEB:deep <q>	8 sources	Heavy duty — compares multiple sources, cross-referenced

Two engines, one seamless result. Primary is Tavily, with Firecrawl as automatic fallback — if one provider is down or rate-limits you, Solaris silently retries with the other. You never see the switch.

Synthesis, not spam. Solaris doesn't dump a pile of links — it reads the sources, synthesizes one coherent markdown answer that quotes the best material, then shows you the source list so you can verify.

Honest about recency. Chat memory is training data + conversation; .WEB is the reality check — real-time answers to questions Solaris genuinely couldn't know.

Every search is logged to the web_log table — query, provider, depth, sources — so you always know where an answer came from.

Note for the curious: .WEB was announced as far back as v1.1.0 — a single line in .HELP marked "WIP". It stayed that way through v1.1.1. This release is where the placeholder finally grew real legs: two providers, three depths, a synthesized-answer pipeline, and permanent search logs. Added back in v1.1.0, skipped for two releases, delivered properly here.

🗂️ Response Commands

.BETTER gives you a specialist; these give you a personal teacher, on demand. Released under the pen name Response Commands, they turn Solaris into a study companion for any topic — no attachments, no setup, just a command and a subject.

.DETAIL photosynthesis
.SIMPLE what is a black hole
.QUIZ world war II
.TIMELINE the roman empire
.COMPARE python vs java
.STEPS how to solve a quadratic equation

Six modes, six ways to learn:

Command	What you get	Best for
.DETAIL <topic>	A full college-lecture-style breakdown with analogies, structure, and thought questions	Actually learning something properly
.SIMPLE <topic>	The same idea stripped to plain language, no jargon	Quick understanding when you're short on time
.QUIZ <topic>	A 10-question quiz with answers	Testing yourself, exam prep
.TIMELINE <topic>	Key events in chronological order	History, progressions, cause-and-effect
.COMPARE <topic>	Side-by-side comparison	"Which should I use/choose?" decisions
.STEPS <topic>	A process broken into ordered, explained steps	How-to's, procedures, workflows

Built on the same engine. Each mode is a purpose-built prompt fed to the same specialist-grade model pipeline .BETTER uses — dual providers, automatic fallback, consistent quality.

Rendered beautifully. Each mode has its own dedicated renderer in the new TUI — quizzes come back as formatted question cards, timelines as structured sequences, steps as numbered guides, comparisons as proper side-by-side tables. Not a wall of markdown, designed output.

📺 The Panelized TUI

The whole interface got a visual identity. tui_utils evolved from a few scattered print helpers into a real panelized rendering system — every response, table, and prompt now lives inside clean bordered panels.

What changed:

• Paneled responses — every AI response arrives in a titled, bordered box with a subtitle, instead of raw text bleeding onto the terminal
• Native markdown rendering — tables, inline code, bold, headers all render properly instead of showing raw **syntax**
• Smart tables — auto-styled tables with column alignment and markdown-aware cells, used everywhere: attachments, detach lists, file/image pickers, .COMPARE
• Specialized viewers — history-style timelines, quiz cards, step guides, each rendered with its own format
• Proper prompt boxes — consistent labeled input frames for every interactive step (file paths, counts, questions), with re-prompting on invalid input built in

Why it matters. Two releases ago, .BETTER and friends printed plain text. As Solaris grew commands, the CLI was turning into a wall of undifferentiated text. Now every action is visually scoped — you can tell at a glance where a response starts, what it's answering, and how to act next. The same feature knowledge, a much calmer screen.

🧠 UX Niceties

• Whispered suggestions, not banners. Attachment tips now render in dim grey — a quiet nudge instead of a bright yellow shout at every attach.
• Solaris talks like Solaris. Rewrote the tips so they sound like the assistant itself giving friendly advice — not a software manual.

*"File attached is a markdown file. I recommend usin...

Properly Tested & Stabilised

Properly Tested & Stabilised

This release focuses on making Solaris a properly tested and stable application.

Following the addition of .BETTER, the entire existing Solaris codebase was comprehensively tested across its core systems, database operations, profile management, commands, specialist AI modes, memory, voice features, configuration, TUI, and fallback systems.

The bugs and reliability issues discovered during testing have been fixed, including critical profile/password issues, command handling problems, incorrect profile information, input validation issues, privacy-related database behaviour, fallback error handling, and several smaller architectural and reliability problems.

This release also includes minor TUI improvements and general reliability improvements across the application.

Highlights

• Comprehensive testing of existing Solaris features
• Critical and high-priority bugs fixed
• Profile and password handling improved
• Command handling and input validation improved
• Privacy and database behaviour fixed
• AI fallback reliability improved
• .BETTER verified across all three specialist modes
• Minor TUI/UX improvements
• General stability and reliability improvements

v1.1.1 is the first release where Solaris is considered properly tested and stable following the .BETTER feature update.

---

Next Update

The next planned update for Solaris is the Response Commands Update which will allow the user to get different types of responses for certain request, like generating quizzes, tables, simple explanation without losing the depth, detailed explanations and more.
After Response Commands, Another Command- .WEB; a Command that allows Solaris to use the web to fetch latest information from the web for the request it was given. Similar to .BETTER, it will only be used for the requests where it was called, and not for the entire session.

Made with LOTS of Debugging, Testing 🥀

Specialised Intelligence Update

.BETTER

Solaris v1.1.0

Detail

.BETTER is the first major update to Solaris, introducing a dedicated system for getting a better response to a specific question through specialised AI models.

The command is especially useful when the response provided by the primary model, the models from the second provider (OpenRouter), or the local Ollama model is not satisfactory and requires a better review, explanation, implementation, or strategic approach.

.BETTER provides specialised modes for Writing, Coding, and Strategy, with two AI models available in each mode. This allows the user to compare responses from two different models specialising in the selected domain.

Except for the Strategist workflow, specialist models are used for one question only, rather than remaining active for the rest of the session. This helps prevent unnecessary model usage and reduces the possibility of hitting provider rate limits.

Because Solaris retains in-session context, the primary models can also use the specialist's response to compare, refine, and improve their own answer.

---

Requirements

This feature requires:

• An active Internet connection
• Nothing else

---

Program Flow

When .BETTER is entered, Solaris presents three options:

1. Writer
2. Coder
3. Strategist

---

Writer

The Writer mode provides two AI models specialised in writing and literary tasks.

The models can either:

• Be provided by default by the developer, or
• Be selected by the user

Their primary purpose is to understand the context and requirements of the user's request and produce an appropriate piece of writing.

Typical use cases include:

• Essays
• Letters
• Emails
• Other forms of written content

The two-model system allows the user to compare different approaches and choose the response they prefer.

---

Coder

The Coder mode provides two AI models specialised in programming logic.

Like Writer, the models can either be:

• Provided by default, or
• Selected by the user

The Coder is not a Coding Agent.

Its purpose is to assist with a specific programming problem by:

• Generating code snippets
• Reviewing code snippets
• Debugging code
• Suggesting improvements
• Reviewing programming logic
• Stress-testing the architecture of a project

It is intended to provide another perspective on a programming problem rather than independently operate the user's entire codebase.

---

Strategist

The Strategist is the most involved .BETTER mode.

It provides two AI models, similarly to Writer and Coder, but uses them through a structured planning process.

Step 1 — Define the Goal

The user first defines their goal.

The goal should preferably be clearly structured and described in a single response.

Step 2 — Planning Questions

The primary planning model receives the goal and asks the user a series of important questions.

A maximum of 10 questions may be asked.

These questions are intended to clarify the requirements, constraints, preferences, and intended outcome before the strategy is created.

Step 3 — Strategy Generation

The user's answers are then provided to the primary Strategist model.

The model uses:

• The original goal
• The user's answers
• The gathered requirements

to produce a detailed:

• PRD, or
• Design Draft

The resulting document provides a structured strategy for achieving the user's goal.

Step 4 — Secondary Model

If the user is not satisfied with the primary model's result, the same task is passed to the secondary Strategist model.

The secondary model receives the primary model's response as additional context.

This allows it to:

• Compare its approach with the primary model's approach
• Identify weaknesses
• Propose alternatives
• Avoid simply repeating the same solution

This creates a practical two-model comparison rather than two completely independent answers.

---

Core Philosophy

.BETTER is designed around a simple idea:

When the normal response isn't good enough, give the user specialised perspectives instead of simply asking the same model to try again.

The two-model approach gives the user control over which response, implementation, writing style, or strategy is ultimately more useful.

At the same time, specialist models are kept scoped to the relevant question instead of being unnecessarily used throughout the entire session.

---

Version

Solaris v1.1.0

First major feature update

.BETTER marks the first major expansion of Solaris beyond its existing primary-response pipeline, introducing specialised AI workflows for Writing, Coding, and Strategic Planning.

Interface & Experience Update

Solaris v1.0.3 — Interface & Experience Update

This release is focused on making Solaris feel less like a Python script and more like a complete desktop assistant. While no major flagship feature has been introduced, almost every interaction has been refined to create a smoother, cleaner, and more polished experience.

---

What’s New

🎨 Redesigned Terminal Interface

The conversation interface has been refreshed with a cleaner, more readable layout. User messages, AI responses, and system output are now visually distinct, making long conversations significantly easier to follow.

⏳ Smarter Waiting Experience

Solaris now provides visual feedback whenever it is busy.

Animated spinners have been introduced for:

• AI response generation
• Speech transcription
• Local AI inference

For voice users, a live recording timer has also been added, making it clear when Solaris is actively listening.

📖 Improved Readability

Long responses now wrap naturally within the terminal, preventing awkward line breaks and improving readability across different terminal sizes.

---

General Improvements

• Improved overall terminal experience.
• Cleaner prompts and conversation flow.
• Better feedback during AI processing.
• Enhanced logging and internal reliability.
• Multiple bug fixes and stability improvements.
• General code cleanup and internal optimizations.

---

Looking Ahead

Development is now focused on Solaris v1.1.0, introducing one of the project’s biggest quality-of-life features yet.

🧠 .BETTER

Rather than asking users to choose an AI model, Solaris will simply ask what kind of help is needed—whether that’s reasoning, programming, writing, or local inference—and automatically select the most suitable specialist behind the scenes.

Future iterations will also allow Solaris to consult multiple specialists when necessary, giving users a stronger and more reliable final answer without requiring them to understand the underlying AI models.

The goal remains the same:

Powerful AI should feel simple to use.

---

Kindly note that .BETTER command is not functional as of now. It will be made functional in the future v1.1.0 release

Thank you for following Solaris’ journey.

Built one feature, one bug fix, and one late-night debugging session at a time.

Refinement Update

Solaris v1.0.2 — Refinement Update

This release focuses on improving the overall experience and making Solaris more polished, stable, and convenient to use.

What’s New

Improved Profile Management

Managing user profiles is now more flexible, including the ability to modify profile privacy settings without creating a new profile through the .UPDATE_PRIVACY command. You can change the privacy settings mid-conversation.

New .CLEAR Command

Added a .CLEAR command to clear the terminal screen while preserving the entire conversation context, memory, and session. It provides a fresh workspace without losing continuity.

General Improvements

• Improved profile selection workflow.
• Better handling of invalid menu options.
• Minor bug fixes and stability improvements.

---

Looking Ahead

Development has already begun on v1.1.0, introducing one of Solaris’ biggest features yet:

.BETTER

Rather than asking users to choose AI models, Solaris will let them choose the kind of help they need—such as Reasoning, Coding, Writing, or Local AI—while automatically selecting the most suitable specialist behind the scenes. If the first response isn’t satisfactory, Solaris will even be able to consult another specialist for a second opinion.

The goal remains the same: make powerful AI feel simple to use.

---

Thank you for following Solaris’ journey.

Built with curiosity, countless experiments, and lots of debugging!

Solaris v1.0.1

New Features

.ABOUT

• View Solaris version and build information
• Display active profile details
• Show AI model stack (Primary, Fallback, Offline)
• View speech input/output configuration
• Display profile statistics and database information

.RENAME

• Rename an existing profile
• Preserves all memories, preferences, and profile settings
• No need to create a new profile for a name change

Solaris v1.0.0

First Public Release

Solaris is a CLI-based AI chatbot featuring persistent memory,
multi-user support, voice interaction, and resilient multi-model AI fallback.

Features

• Multi-user profiles
• Public & Private profiles
• Persistent long-term memory
• Current session memory
• AI preference summarization
• Voice and text interaction
• EdgeTTS and KittenTTS
• Gemini → OpenRouter → Ollama fallback
• SQLite database
• System logging
• Runtime profile switching

Built With

• Python
• SQLite
• Gemini
• OpenRouter
• Ollama
• Faster-Whisper
• EdgeTTS
• KittenTTS

This marks the first stable public version of Solaris.
Future releases will focus on improving usability,
memory retrieval, and overall architecture.