Devlog 09

hey guys, I’ve reached 10 hours so I need to make a devlog (not finished with what im currently working on.)

Alot has been done in this 10 hours, and I am almost ready to ship. I’ve finished up a bunch of backend wiring and bugfixes.

Updates:

• Useless buttons: Removed the color palette button and the crop button; don’t think I’ll be working on crop (maybe later), and I dont have different sections to use the color button for.
• Zoom: The zoom buttons were just placeholders during the previous devlog. I implemented working zoom that allows you to also pan when the zoom is above 100%. (very tricky, encountered a bunch of flickering issues). You are also now able to zoom in via the mouse scroll wheel.
• Filmstrip removal: I deleted the whole filmstrip section (again, a placeholder at the time). I might come back to it though.
• Color module additions: I added Shadow Tint and Highlight tint into the Color category. Not much else to say for this.
• Color channels: I built the UI for the Channels category and the Red, Green, and Blue channel sliders. And then of course wired them up to the full color pipeline.
• EFFECTS :D : Added the effects section to the UI, which include adjustments like Clarity, Vignette, Blur and Sharpen. And wired them up to the backend.
• Transform module: Flip H, Flip V, Grayscale. Can’t say alot about these either, pretty self explanatory. Rotate and reset buttons have also been added at the bottom of the right adjustments box. (90deg to the right.)
• Auto select: This is my new auto enhancement feature. This uses edge detection alongside bright spot detection to lower the brightness on overly popping spots. Balances out the image a little more.

Whats next?

The project is close to being completed. I will finish up some optimizations (most likely with some AI agent to make the code as efficient as possible).

• Bug fixes: Every image that is seen from the viewfinder contains a blue tint (currently working on removing this)
• Prepare RawStudio for final deployment to Render
  – I will be using my domain for final deployment, so the final URL will probably be: rawstudio.kavnvn.xyz.

Shipping will occur right after the next devlog.

Devlog 08

hi guys :D.
I’ve added a solid amount of features since the last devlog. Last ver was just a basic canvas with some adjustment sliders, but now I have the UI looking like a proper editing app.

Updates:

• Histogram: I added the RGB histogram that used to be present in the Pyqt version. Overall just helps keep track of the tones throughout the image.
• Fimlstrip: Added a filmstrip at the bottom, which displays active images so you can easily browse thru all the pics you’ve imported.
• Exif metadata: I added a overlay tag on the top left that displays ISO, aperutre, shutter speed, and focal length. The screenmshot that I provided just has synthetic info, I imported a png.
• Status: Bottom bar tracks canvas dimensions.
• UI and refactoring: I reorganized the structure a little, added standard icons, the components fit into clean rows and containers.
• Backend wiring: Wired up most backend features into the UI, including image selection/importing, histogram data, light adjustment bars, color adjustment bars, & the save button.

Whats next?

• Finish wiring up the rest of the UI features to the backend, which include the cropping, zoom, and new feats I will be adding.
• Will most likely be adding an auto-select tool that uses edge recognition to select specific objects, the kinda tool that other apps like GIMP and Photoshop use.
• Shipping will occur within the next 2 devlogs (hopefully)

Devlog 07

hello guys :D.

Ive found a MUCH better looking UI library than pyqt and my prev builder for Cortex, which was Streamlit. We all know Streamlit is ugly. Like damn. Anyway, I’ve started on building a Flet UI now.

Flet has been a very good alternative for the UI. Comes with a bunch of prebuilt flutter components, and everything can be integrated with Python (sadly im alr at any other language). Its all cross platform too, so I could make it either a web app or desktop app, but I will most likely be making it a web app (easier for voters to use, not everyone has python installed.) Heres everything I added:

New updates:

• UI Revamp: As I said before, I switched out the entire PyQT interface to Flet. Alot cleaner and dark themed, + everything fits in a single file.
• Extracted prev componenets: I built a slider row func to help speed up the slider creation process, handle the min and max bounds, and display live number readouts without having to duplicate the same sections of code.
• New layout: I setup the main app layout with a bunch of the Flutter widgets.
• Parameter organization: I grouped together the image adjustment parameters into ExpansionTile panels for Light (like Exposure, Contrast, Highlights, etc.) and Color (Temp, Tint, Saturation).
• Header and toolbar: I refactored the top navbar with some Open and Save buttons, + a minimal left hand bar with basic tools like crop and zoom.

Whats next?

• Wiring backend: None of the backend is currently connected to the UI, its just pure nonfunctional UI code, so will be doing that before the next devlog.
• Implementing remaining features: I have yet to add the left out features like the histogram, tone curves, and I will also be adding Color wheels (hopefully)
• Shipping will most likely occur within the next 2-3 devlogs

Devlog 06

hey guys.
I spent this devlog time upgrading control feel and shadow adjustment, plus some more UI work.

New updates:

• Shadow Recovery: I added a custom tone adjustment system that targets the dark areas of an image without completely blowing up the whole photo. Instead of turning up the whole brightness of the imnage, it isolates dark pixels and lifts them with a curve, so the colors stay natural.
• Preserving details: Added a hfq filter to pass over the shadow mask, so the texture and sharpness stay intact. This helps the dark areas not look so flat or washed out when they are lifted.
• Color noise reduction: Higher shadow lifts can bring out some ugly noise, so I added an automatic desaturation to the extremely dark areas to keep the colors clean when the shadow details are recovered.
• Sidebar: I redesigned the sliders in ui.py. The shadow control has its own section with number readouts.

Whats next?

• Binding main up: I will be finishing updating main.py handlers and the events listeners, stuff like keyboard shortcuts and adjustments via the scroll wheel, to connect the new shadow slider.
• Highlights: Ill be adding highlight recovery to lower details from the overexposed areas.

Really dont have alot of new UI modules I added in the screenshot, but next devlog will most likely be a REALLY big UI revamp. Or probably after the next devlog.

Devlog 05

hello guys
I’ve finished up some major UI changes and modularization, along with performance changes.

Updates:

• Modularized some features: refactored some ui code out of main.py into ui.py to organize components better.
• Vignette masking - I’m currently working on a vignette (edge darkening) effect with cv2s gaussian kernel feature. Took a little bit of research to start building this, but I have a matrix with intensity values, which are applied to all the BGR channels.
• Aspect ratio cropping: I built a slicer for the standard ratios (1:1, 4:3, 16:9)
• Control sidebar: I replaced the simple buttons and sliders on the bottom with a right hand sidebar layout. Theres now dedicated cateogries/control sections, parameter sliders, aspect ratio (I acc havent added this yet), & file actions.

Whats next?

• Wiring up the UI: Ill be finishing the main.py and UI module updates to handle the vignettes and new sidebar controls.
• Tone adjustments: Adding Highlight and Shadow mask sliders.

Devlog 04

hey gus.
some pretty large changes were added.

I’ve been working on updates to improve visual feedback on edits and just UI responsiveness.

Updates:

• RGB Histogram: I built a live frequency visualizer for each channel with OpenCV. It displays the distribution curves of red, green, and blue channels all at the same time, which helps alot once we add shadows, highlights, and this also just helps with balancing the tone.
• Before and after comparison: I added a Compare button. Holding the button instantly displays the original image, and letting go reverts to the current edited image.
• Preview and histogram optimization: Ive fixed UI lag during slider updates by making a seperate preview pipeline, so now the canvas processes the slider adjustments on a downscaled preview image (max 1280 px) and uses array sampliong with strides to calculate the histogram. This helped with frame rate ALOT, it kept the editing smooth and the full high res image comes out during export anyway.

Whats next?

• Sidebar tab UI: The sliders are all cluttered in the bottom center right now, different categories on the right in a sidebar would make the app alot more organized.
• Modularizing: Im going to be refactoring a bunch of the UI and processing handlers out of main.py into different modules to clean up the codeboase.
• All these next edits are just for organization and cleanliness, I dont think I’ll be adding any new adjustment features before the next devlog.

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.