Gsoc 2026 Reference Implementation for concore Library in Julia.

[GaneshPatil7517]

Hey @pradeeban @Rahuljagwani @mayureshkothare
Understanding of the Project
I have thoroughly explored the concore repository and understand that it is a lightweight framework designed for closed-loop peripheral neuromodulation control systems. The framework enables communication between different components (controllers, plant models, observers) through a file-based inter-process communication mechanism.

Key observations from my code review:

Core Functions: The library provides essential functions like:

• concore_read() / concore_write() - for reading/writing port data
• concore_iport() / concore_oport() - for port initialization
• concore_initval() - for setting initial values
• concore_default_maxtime() - for timeout configuration

Existing Implementations: concore currently supports:

• Python (concore.py) - Primary reference implementation
• C++ (concore.hpp) - Header-only implementation
• MATLAB/Octave (.m files) - Multiple function files
• Verilog (concore.v) - Hardware description support
• Architecture: The framework uses a directory-based communication model where each port creates a subdirectory, and data is exchanged via files with retval/simtime tracking for synchronization.

Docker Support: The concoredocker.* variants provide containerized execution capabilities.

Proposed Approach for Julia Implementation
I plan to create a complete, idiomatic Julia implementation that mirrors the Python reference while leveraging Julia's unique strengths:

Phase 1: Core Module Development (Weeks 1-4)

Implement Concore.jl module with all core functions
Create Julia-native file I/O operations with proper error handling
Implement the retval/simtime synchronization mechanism
Design type-safe port data structures using Julia's type system

Phase 2: Enhanced Features (Weeks 5-8)
Implement ConcoredDocker.jl for container support
Add comprehensive logging and debugging utilities
Create Julia-specific optimizations (using multiple dispatch, macros where appropriate)
Ensure thread-safety for concurrent operations

Phase 3: Testing & Documentation (Weeks 9-11)
Port existing Python examples to Julia
Create comprehensive unit tests using Julia's Test standard library
Write detailed documentation with Documenter.jl
Performance benchmarking against Python implementation

Phase 4: Integration & Polish (Week 12)
Integration testing with existing concore ecosystem
Code review incorporation and final refinements
Create tutorial notebooks demonstrating Julia usage
Package registration preparation for Julia General Registry

module Concore

export concore_read, concore_write, concore_iport, concore_oport, concore_initval

mutable struct ConcoreState
simtime::Float64
retval::Int
iport::Dict{String, String}
oport::Dict{String, String}
initval::Dict{String, Any}
maxtime::Float64
verbose::Bool
end

const concore = ConcoreState(0.0, 1, Dict(), Dict(), Dict(), 50.0, false)

function concore_read(portname::String, maxtime::Float64=concore.maxtime)
# Implementation following Python reference
# File-based synchronization with retval checking
end

function concore_write(portname::String, data::Any, delta::Float64=1.0)
# Write data to port file with simtime update
end

end # module

Current Progress

I have already drafted a proposal that is approximately 90% complete, covering:

Detailed timeline with weekly milestones
Technical architecture and design decisions
Risk assessment and mitigation strategies
Testing and validation methodology

I would be grateful to share this draft with you in the next 2 days for your valuable feedback before the official submission deadline. Your insights would help me refine my approach and ensure alignment with the project's vision.

Questions for Mentors
I would appreciate your guidance on the following:

API Consistency: Should the Julia implementation strictly mirror the Python API, or are there Julia-specific improvements you'd welcome?

Priority Features: Are there any specific features or use cases that should be prioritized in the Julia implementation?

Integration Testing: What existing examples/demos would you recommend I focus on for end-to-end testing?

Package Distribution: Do you have preferences for how the Julia package should be distributed (Julia General Registry, project-specific registry, or direct GitHub installation)?

Performance Considerations: Are there any performance-critical sections where Julia's speed advantages should be specifically leveraged?

[GaneshPatil7517]

hello @pradeeban sir my praposal is ready were i can share that with you........?

[pradeeban]

You can submit through the GSoC portal when the application period starts (or email me and cc all the mentors in the SAME email) with your draft.

API Consistency: Should the Julia implementation strictly mirror the Python API, or are there Julia-specific improvements you'd welcome?

Feel free to use Julia-specific approaches.

Priority Features: Are there any specific features or use cases that should be prioritized in the Julia implementation?

Check the current C++ and Verilog implementations. As minimal alternative implementations, they will give you some clue.

Integration Testing: What existing examples/demos would you recommend I focus on for end-to-end testing?

Check the concore-lite repository to see how to start a minimal alternative.

Package Distribution: Do you have preferences for how the Julia package should be distributed (Julia General Registry, project-specific registry, or direct GitHub installation)?

No preference about Julia General Registry. You can include your approach in your proposal. A direct GitHub installation surely should be supported.

Performance Considerations: Are there any performance-critical sections where Julia's speed advantages should be specifically leveraged?

Nothing that comes to mind.

[GaneshPatil7517]

Thank you so much @pradeeban sir for the detailed and thoughtful responses This is incredibly helpful. I've noted all your feedback and have incorporated it into my proposal:

API Consistency: I've designed the Julia implementation using Julia-specific approaches leveraging multiple dispatch, parametric types, and idiomatic Julia patterns rather than a strict Python mirror. This should make the API feel natural for Julia users while maintaining full functional compatibility.

Priority Features: I've studied both the C++ (concore.hpp) and Verilog (concore.v) implementations in detail. Their minimal, focused structure has guided my approach to prioritize core file-based communication, synchronization primitives, and the essential API (read, write, unchanged, initval, default_maxtime, tryparam) before adding advanced features like ZeroMQ.

Integration Testing: I'll review the concore-lite repository to understand the minimal alternative structure and use it as a reference for building end-to-end tests. This will also help me structure the Julia package as a clean, minimal implementation.

Package Distribution: The primary distribution method will be direct GitHub installation:

Pkg.add(url="https://github.com/ControlCore-Project/concore.jl")
ulia General Registry submission can be explored later if desired.

Performance: Understood I'll focus on correctness and cross-language interoperability as the primary goals, without over-engineering for performance.

My draft proposal is ready. I'll submit it through the GSoC portal when applications open on March 16, and I'll also emailed it to you and all the mentors in the same email as you suggested.

Looking forward to your feedback...
thank you so much again @pradeeban sir, @Rahuljagwani sir, @mayureshkothare sir.......