Open Source Database GUI

DocKit is a fully open-source database GUI client, licensed under Apache 2.0. Every line of code is publicly auditable, community-driven, and free from vendor lock-in.

Why Open Source Matters for Database Tools

🔍 Transparency & Trust

When managing production databases, you need to know exactly what your tools are doing:

Closed-Source Tools:

• ❓ Unknown data collection
• ❓ Hidden telemetry
• ❓ Potential security vulnerabilities
• ❓ Vendor-controlled updates

DocKit (Open Source):

• ✅ Every feature is visible in source code
• ✅ No hidden data collection
• ✅ Community security audits
• ✅ You control when to update

Example: Credential Handling

In closed-source tools, you trust the vendor's claim about credential security.

With DocKit, you can verify:

// Source: https://github.com/geek-fun/dockit
// Credentials encrypted using OS keychain
pub fn store_credentials(profile: &Profile) -> Result<()> {
    let keyring = Keyring::new("DocKit", &profile.name);
    keyring.set_password(&encrypt(profile.secret))?;
    Ok(())
}

🔒 Security Through Scrutiny

Open source enables:

• Public Security Audits: Anyone can review for vulnerabilities
• CVE Response: Community discovers and fixes issues quickly
• No Backdoors: Impossible to hide malicious code
• Reproducible Builds: Verify binaries match source code

Real-World Impact:

• Heartbleed (OpenSSL): Discovered and fixed by community
• Log4Shell: Open source allowed rapid patching
• Closed-source tools: Vulnerabilities hidden for years

💰 No Vendor Lock-In

Proprietary database clients create dependencies:

Aspect	Closed-Source	Open Source (DocKit)
Pricing Changes	Vendor can raise prices	Always free
Feature Removal	Vendor decides	Community decides
Platform Support	Limited to vendor priorities	Community adds platforms
Data Export	Proprietary formats	Open formats (JSON, CSV)
Customization	Feature requests only	Fork and modify
Longevity	Depends on company	Code persists forever

Example: Dynobase

If Dynobase:

• Raises prices to $100/month
• Removes a critical feature
• Discontinues the product

Users are stuck. With DocKit (open source), the community continues development.

DocKit's Open Source Approach

Apache 2.0 License

The most permissive open-source license:

• ✅ Commercial Use: Use in companies without restrictions
• ✅ Modification: Fork and customize for your needs
• ✅ Distribution: Share modified versions
• ✅ Patent Grant: Protection against patent claims
• ✅ Private Use: No obligation to share changes

What This Means:

• Enterprises can use DocKit internally
• Consultants can bundle DocKit with services
• Developers can create proprietary forks
• No licensing fees or compliance issues

Community-Driven Development

DocKit is built by developers, for developers:

Contribution Process:

1. Open Issue: Report bugs or request features
2. Discussion: Community weighs in on priorities
3. Implementation: Anyone can submit pull requests
4. Review: Maintainers + community review code
5. Release: New features shipped to everyone

Who Contributes:

• Individual developers
• Companies using DocKit
• Database experts and SREs
• Security researchers
• UI/UX designers

Public Roadmap

All development happens in the open:

• GitHub Issues: Feature requests and bug tracking
• GitHub Projects: Roadmap and sprint planning
• Release Notes: Detailed changelog for each version
• Design Discussions: Public RFC process

See the Roadmap:github.com/geek-fun/dockit/projects

Comparing Open Source vs. Closed Source

Dynobase (Closed Source)

Unknown:

• Internal architecture
• Security practices
• Data handling
• Future pricing

Risks:

• Vendor can change terms
• No community contributions
• Limited to official features
• Dependent on company viability

AWS DynamoDB Console (Proprietary)

Limitations:

• Tied to AWS ecosystem
• Can't inspect code
• No offline version
• Changes at AWS's discretion

DocKit (Open Source)

Transparent:

• Full source code available
• Community security audits
• Public development process
• Documented architecture

Advantages:

• Community-driven features
• Customizable for specific needs
• Forever free
• No business risk

Security Benefits of Open Source

Public Vulnerability Disclosure

DocKit follows responsible disclosure:

1. GitHub Security Advisories: Private reporting
2. Patch Development: Community collaboration
3. CVE Assignment: Public tracking
4. Rapid Deployment: Update within days

Recent Example (Hypothetical):

CVE-2024-XXXXX: Credential exposure in connection export
- Discovered: Jan 15, 2024 (community member)
- Patched: Jan 16, 2024 (maintainer + contributor)
- Released: Jan 17, 2024 (v0.9.1)
- Impact: Low (requires local file access)

Closed-source tools may take weeks/months to disclose.

Auditability

Organizations can audit before deployment:

Compliance Use Case:

# Clone repository
git clone https://github.com/geek-fun/dockit

# Review source code
cd dockit
grep -r "network" src/  # Check network calls
grep -r "telemetry" src/  # Verify no tracking

# Build from source
cargo build --release

# Deploy internally

Industries That Require This:

• Healthcare (HIPAA compliance)
• Finance (SOC2, PCI-DSS)
• Government (security clearance)
• Defense (air-gapped systems)

Open Source Ecosystem Integration

Compatible with Open Source Databases

DocKit supports open-source databases:

• OpenSearch: Amazon's open fork of Elasticsearch
• DynamoDB Local: Open-source local testing tool
• Elasticsearch: Open-source search engine (pre-license change versions)

Together, you have:

• Open-source database
• Open-source client
• Open-source deployment (Docker/Kubernetes)
• Complete transparency

Extensibility

Open source enables custom extensions:

Example: Custom Export Format

// Fork DocKit and add custom exporter
export function exportToProtobuf(results) {
  // Your proprietary format
  return protobuf.encode(results);
}

Example: Internal Theme

/* Corporate branding */
:root {
  --primary-color: #FF6B00; /* Company orange */
  --logo: url('/internal/logo.png');
}

Integration with Internal Tools

Open source allows:

• SSO Integration: Add corporate authentication
• Audit Logging: Send queries to internal SIEM
• Custom Connectors: Support internal databases
• Workflow Automation: Trigger CI/CD pipelines

Community Support

GitHub Discussions

Get help from the community:

• Q&A: Ask questions about features
• Show and Tell: Share your use cases
• Ideas: Suggest improvements
• Polls: Vote on new features

Issue Tracking

Report problems and track fixes:

Issue #123: PartiQL syntax highlighting incorrect for nested queries
- Status: Open
- Priority: Medium
- Assignee: @community-member
- ETA: v0.10.0

Contributing Back

Help improve DocKit:

1. Bug Reports: Detailed reproduction steps
2. Feature Requests: Explain your use case
3. Code Contributions: Submit pull requests
4. Documentation: Improve guides and examples
5. Testing: Beta test new features

Contribution Stats:

• 50+ contributors
• 200+ merged pull requests
• 1,000+ GitHub stars

Commercial Support (Optional)

While DocKit is free, commercial options exist:

Support Tiers

Tier	Description	Price
Community	GitHub issues, discussions	Free
Priority	Slack access, faster responses	Coming soon
Enterprise	SLA, custom features	Contact

Note: Code remains open source regardless of support tier.

Enterprise Features (Planned)

For large organizations:

• SSO/SAML Integration: Corporate authentication
• Audit Logging: Centralized query tracking
• Role-Based Access: Team permission management
• On-Premise Deployment: Self-hosted licensing server

All code still open source, just gated behind configuration.

Getting Started with Open Source DocKit

1. Star the Repository

github.com/geek-fun/dockit ⭐

2. Download Binary or Build from Source

Option A: Pre-Built Binaries

# Download from GitHub Releases
# https://github.com/geek-fun/dockit/releases

Option B: Build from Source

# Clone repository
git clone https://github.com/geek-fun/dockit
cd dockit

# Install Rust toolchain
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Build
cargo build --release

# Binary at: target/release/dockit

3. Join the Community

• GitHub Discussions: Share ideas
• Discord (coming soon): Real-time chat
• Newsletter: Monthly updates

4. Contribute

Even non-developers can help:

• Documentation: Fix typos, improve examples
• Testing: Report bugs, test beta versions
• Feedback: Share feature ideas
• Spread the Word: Tweet, blog, recommend

Why Companies Choose Open Source

Cost Savings

Scenario: 20-developer team

Tool	Annual Cost	5-Year Cost
Dynobase Pro	$2,880/year	$14,400
DocKit	$0	$0

Savings: $14,400 over 5 years (per team)

Risk Mitigation

Open source reduces business risks:

• Vendor Bankruptcy: Code persists
• Price Increases: Always free
• Feature Removal: Fork if needed
• Platform Support: Community adds platforms

Compliance & Audit

Auditors prefer open source:

• No Black Box: Review all code
• Vulnerability Tracking: Public CVE database
• Build Verification: Reproducible builds
• License Clarity: Apache 2.0 is well-understood

Learn More

• GitHub Repository - Source code & issues
• Download DocKit - Pre-built binaries
• Local-First Design - Privacy architecture
• Desktop Client Benefits - Native app advantages
• DynamoDB GUI - Main product page

---

Want to contribute? Read our Contributing Guide or open your first issue!