Devlog 03

hello.
I’ve finished up some major updates, 2 for image adjustments and one for refactoring

New updates:

• Non linear exposure control: I added an exposure slider using gamma correction and cv2.lut. The precalculated lookup table makes sure the slider responds smoothly without any lag.
• Color tmep slider: I integrated a color temperature control slider to change the white balance of an image. The warm values boost the red channel and reduce blue, and cool values boost blue and reduce red.
• Refactor: main.py just started getting really crammed, so I moved all the image processing code into a function in processor.py. Now, main.py only manages the UI components and the processor wiring.

I’ve also spent a bunch of time experimenting with different filters to add, I’m hoping to add these before the next devlog, not too sure though.

Whats next?

• RGB histogram: will make a pixel intensity graph with matplotlib and pyqt to display highlights and shadows.
• Before/After toggle: maybe a shortcut to toggle a before and after view just like lightroom has
• Slider categories: organize the sliders into seperate categories based on their use case
• Filters: different image filters like grayscale, sepia, etc.

Devlog 2

hey guys.
I have added ALOT of features since the last devlog.

New features:

• Saturation and RGB controls: I’ve added a saturation slider by converting the image to HSV and then scaling the saturation. Theres also individual red, green, and blue sliders so you can change up the balance.
• Blur and sharpening: Added a Gaussian blur slider and built a sharpening filter with an unsharp mask. It basically just blends a blurred copy of the image into the original image to make everything pop.
• Transformations: I added a 90 degree rotate button along with horizontal and vertical flips, so you can quickly fix incorrect photo orientations. Also added a reset button to clear all changes to the original image.
• Exports: Theres now a working save file dialog with opencv’s file writer, so you can export the modified images as png, jpg, or bmp.

Finally starting to become an actual app :D.

I also added a banner/logo to the project, you can view it in my project page. Designed in Figma.

Whats next?

main.py is very cluttered with all the logic and processing in a single file. I know I said that I would do the modularization in the previous devlog, but I will acc be modularizing between this and the next devlog.

Devlog 01

hey guys, first devlog for RawStudio.

RawStudio is a desktop photo editor that I’m building in Python.

What have I done so far?

• base canvas is running
• file picking and canvas image loading
• controls for brightness, contrast, and grayscale

I ran into an issue today where OpenCV imported images in bgr instead of rgb, which made the loaded photos look only blue. Easy fix, I just switched the channels before sending them to the pixmap.

What’s next?

• I will be separating main.py into different modules to keep the codebase more organized

Devlog 11

I’m just doing this last devlog before the first ship, so that I get the remaining time I spent working on the readme.

The complete readme.md is finished, including all the features, development tools, tech stack, and more. I will be shipping now.

Devlog 10

hello :D.

the first version of Cortex is ready to ship.

After I modularized the components, I finished up the strategy builder module and the UI in streamlit. So now you can make your own custom no-code entry and exit rules.

The app is deployed on Render. I’ve bought a domain for it, and linked that up to the Render link.

The current UI takes in whatever rules you set, fixes up the signal logic, and then hands it to the backtester so you get results pretty much instantly.

What I got working for the builder:

• Add, delete, change multi condition rules using basic boolean logic
• Compare indicators against fixed numbers or just evaluate 2 strategies against eachother, eg SMA and EMA
• Calculates indicators ahead of time and edge cases like NaN crashes and random state resets.

What’s next?

README, full runthrough to make sure everything runs smoothly, and then the first ship.

Devlog 09

hello :D.

With the bridge now running, I built out the full app.py dashboard to test all the ui features, strategies, and visual analytics like the graphs. Its currently all in a singular file before I split it into seperate components.

All the Streamlit app does is gather parameters from the sidebar, send them to CortexBridge, and create a render of the returned metrics/payload.

What I’ve added to the dashboard:

• Full strategy support (choose from dropdown in sidebar)
• Date range controls & friction inputs: added execution start/end date selectors + interactive sliders for initial capital, commission fees, and slippage %
• Chart shows equity curve performance
• Downloadable CSV exports for trade logs and JSON backtest reports

What’s next?

The dashboard logic is complete, next up is to modularize it into different components. I will most likely also be adding a custom strategy building system soon.

Devlog 08

hi :D.

Before writing out the Streamlit code, I decided to setup the actual pipeline to connect the frontend to the backtesting engine. bridge.py now handles the transfer of UI control outputs to commands in the engine.

All the streamlit app has to do now is pass input parameters into CortexBridge and receive a payload. This makes sure the web client and backend stay completely seperate.

Bridge features:

• BacktestPayload is the dataclass that returns everything Streamlit will need. This includes the formatted metrics (Total return, Sharpe, etc.), the equity curve df, the trade history table, and execution logs.
• looks for local sqlite databases, falls back to local csv files, or generates synthetic data if the ticker data isn’t available
• signals are delayed by 1 bar so that the strategy can’t cheat by knowing the future prices, and trading costs like fees and slippage are also factored into every executed trade
• bunch of error handling and logging

Whats next?

Next up is building the full Streamlit layout and hooking it up to the bridge.

Devlog 07

Hello :D.

I’m at 10 hours so I have to make a devlog. I will be dropping the tkinter gui completely.

Tkinter is genuinely terrible for this project, I’ve spent too long making the dark theme frames and canvas charts, and the UI still looks very old and bad.

I will be switching the whole frontend to Streamlit. Streamlit is alot easier to use and is way more convenient. Streamlit also converts Cortex into a web app instead of having to download and run it locally. Alot better for users who just want to test it.

The Streamlit building experience also seems better, as they have prebuilt UI components, proper charting libraries, and easier deployment.

Whats next?

I am scrapping the tkinter app. I will start building the backend wrappers and logic to connect with the Streamlit frontend.

Devlog 06

Hello :D.

Since the last devlog, I’ve gotten started on creating the complete pipeline. I started on a script for a complete backtest run.

Majority of the time in this devlog was taken up by my frontend work that I just started. This has been the hardest part so far (for me), I don’t remember the last time I’ve had to use tkinter.

Current features in the UI:

• Ticker selection and date range picker (to retrieve stock data)
• Strategy parameters (fast/slow SMA periods)
• Risk controls (initial capital, commision %, slippage %) to improve backtesting accuracy
• List of all trade executions

I haven’t implemented matplotlib to show the equity curve and drawdown, that will most likely be up next. The current UI also just feels very blocky and sharp, I will be smoothening everything out.

Whats next?

I’ll be implementing the chart using Matplotlib for equity curves and drawdowns, and fixing up the styling/layout.

Devlog 05

hey guys :D.

I’ve finally completed the PerformanceMetrics module. This allows the program to now display trade stats, WLR, return metrics, and alot more.

I also added 4 new strategies for the EMA, Stochastic, ADX, and ATR indicators that I added in the prev devlog.
Main.py was also of course updated to handle the metrics. I’ve also just began work on the full pipeline and data wrappers. After that will come the frontend development.

Devlog 04

Hello :D.

Last devlog I finished up the backtesting engine, strategy module, and added 2 new indicators.

3 new indicators were added to the TechnicalIndicators module:

• Stochastic Oscillator
• ADX (Average directional index - trend strength)
• ATR (Average true range - volatility)

My strategy module was also updated to generate signals for the MACD and Bollinger Bands indicators.

Majority of my time has been taken up by the new PerformanceMetrics module I’ve been working on. This module evaluates the backtesting results with return, risk, drawdown, and trade statistics. It still isn’t finished, but will definitely be done before the next devlog.

Whats next?

Next up will just be more addition of indicators and strategy refinement. After I’ll be setting up the backend wrapper and data handlers to work with the frontend (which I will develop later).

Devlog 03

Hello :D.

Last devlog I migrated everythng to SQLite and built out a few technical indicators.

Devlog took this long as I was working on the backtesting engine for a while. Took a while to understand what was going on when I first tried to work on trade execution, create the cash vs holdings trackng, and the entry exit logic.

I did get a full simulation working that has slippage, comissions, and risk management like stop loss and take profit.

I’ve also added the strategy module to turn indicator outputs into buy and sell signals. 2 new indicators were also added:

• MACD (Moving Average Convergence Divergence)
• Bollinger Bands

main.py was also of course updated to handle the new modules.

Devlog 02

Hello :D.
Last time, I had a script that pulled stock data from yfinance, flattened the dataframes, and saved the data to JSON and CSV files.

For this update, I migrated to an actual local database, created separate modules, and built out the first bit of the indicators.

I switched over to an SQLite database, and as everything was getting too crammed in the main.py, created separate modules for handling the database and fetching yfinance data, which include the DatabaseManager and DataFetcher classes.

I’ve started out on building indicators.py to compute technical indicators. So far I’ve implemented:

• SMA (Simple Moving Average)
• EMA (Exponential Moving Average)
• RSI (Relative Strength Index)

I also updated main.py to handle all the new modules and work with the SQLite database.

Whats next?

I will most likely start building out the strategy part to generate signals based on the indicator outputs.

Devlog 01

Hey guys :D. First devlog of Cortex, heres a quick overview:

Cortex is a backtesting and market analysis platform that I’m building to test algotrading strategies.

For this first update, I got the main data pipeline working. All my data is coming from yfinance. I setup yfinance to pull 2 years of daily OHLCV data for 6 tickers (AAPL, MSFT, GOOGL, NVDA, SPY, and AMZN). pandas returns MultiIndex columns, so I had to format everything into a flat table. The formatted JSON and CSV files are also exported.