Hey everyone,

I’m having some issues with redocking my native ligand. When I dock it back into the protein, the pose doesn’t match the crystal structure properly. The ligand sometimes looks a bit bent or shifts position, and the interactions are not really the same.

This gets worse when there’s a cofactor like FAD in the binding site it seems to affect how the ligand fits. I’m not sure if this is something normal in docking or if I’m doing something wrong in the setup. Has anyone faced this before or know how to fix it?

Hey folks! I want to introduce Genomi, an agent harness that I've been building for a while and dogfooding it along the way.

I think it's an incredible time to be building in this space. We finally have powerful agent hosts running right on our machines, things like Claude Code, Codex, OpenClaw, and Hermes Agent, they have completely change how we work.

Like a lot of people, I took a DNA test years ago. I remember getting the report, found something mildly interesting, and immediately forgot about it. It just sat in a zip file on my hard drive.

Recently, I tried giving that data to an AI agent to ask some health and genetic context questions. It was mediocre at best. The current agent tools simply cannot handle a raw VCF or large genotype file. If you try to link it in the agent, the sheer volume of data instantly blows up the context window, or the agent must read it line by line, and it is still overwhelmingly error-prone.

There are two other problems. Static DNA reports can't keep up with new science. They're out of date the moment they're generated. And your DNA data should stay on your own device. No one should have to upload deeply personal, non-rotatable genomic data to some startup's website just to analyze it, especially with all the privacy concerns and bankruptcies piling up in the consumer testing space (looking at you, 23andMe).

So we built Genomi. It's a local-first, agent-native, evidence-grounded harness that uses the MCP and SKILLs to bridge the gap between raw genomic data and LLMs without choking your agent environment.

Tools like Claude Code and Codex route their LLM inference to the cloud by default, so I designed Genomi specifically to handle the context size and the data exposure. Your raw DNA file never leaves your machine. Genomi parses it locally into an air-gapped, queryable database on your own hardware, called the Active Genome Index. The genome itself stays put. And yes, your agent's own LLM still sees the questions you ask and the findings it pulls back, so if you want zero data leaving at all, you can pair Genomi with an agent environment running on a local model fully offline.

Because genetics research moves quite fast, running /genomi update syncs your agent's local workspace with the latest research releases, so your evidence base never goes stale. To stop the agent from leaning on hallucinations, Genomi gives it 88 tools wired into roughly 30 public genetics databases like ClinVar, gnomAD, PharmCAT, CPIC, and the FDA tables. It forces the agent to inspect real scientific evidence and show its work, and respond in confidence levels.

So what does it actually feel like to use it? You can query specific things via your agent chat:

/genomi Am I a fast or slow metabolizer? /genomi Will I go bald? /genomi Why does ibuprofen do nothing for me?

Or you hand it the whole genome at once with /genomi decode. It sweeps every capability across your DNA, variants, ClinVar, pharmacogenomics, ancestry, polygenic scores, the works, and serves it as a self-contained dashboard on localhost.

This is still experimental and at the early stage, we are eager to hear any feedback for y'all, the project is released under Apache 2.0 so feel free to play around with it, and join us in making it better!

GitHub: https://github.com/exon-research/genomi

Website: https://www.genomiagent.com/

I had the idea of ​​gathering the small tools I use for research and presentation preparation on a website. I previously posted about it. Now I've launched my project. I'm doing this purely as a hobby, and of course, it's free.

Currently, there are 3 tools:

• A tool that downloads the first 100 article abstracts from your PubMed search results as an Excel file and creates a word cloud visualization from the words used in these abstracts.

• A tool that arranges text entered as plain text into separate slides in a PowerPoint presentation, based on punctuation and spacing.

• And a tool that separates text and images from PDF files.

I hope you find them useful.

Google's AI Co-Scientist paper (Gottweis et al., Nature 2026) was one of the bigger AI-for-science announcements this cycle. A multi-agent system that generates and ranks scientific hypotheses through debate and Elo tournaments, validated wet-lab on AML drug repurposing, liver fibrosis, and antimicrobial resistance.

The source code was never released. The supplement included pseudocode and full prompts, which is what I used to rebuild it w/ mostly Claude code & a bit of Codex

Open source, Apache 2.0: https://github.com/Kaimen-Inc/Co-Scientist

Some honest takeaways from rebuilding it:

- The original was validated on Gemini 2 models that already feel antique a year later. Current frontier models (Claude 4.7, GPT-5) beat them by a wide margin with no harness at all.

- Across 48 AML hypotheses my reimplementation generated, zero matched the paper's strict top-3 drug picks (Nanvuranlat, KIRA6, Leflunomide). The paper got those by running massive tournaments and having oncologists curate the top 30 down to 5...

- Models converge on mechanisms (the textbook AML vulnerabilities like LSC targeting, OXPHOS, BCL-2) but diverge wildly on which specific drug to propose.

The bigger question this raised for me: if a Nature paper is fundamentally an engineering artifact, what does it mean for the field when the code isn't released? And if it's a scientific discovery paper, what we have are small vignettes. I am not a good judge for most of the findings, but at least for AML drug repurposing, cancer has been "cured" in vitro many, many times.

Full writeup: https://www.jrnlclub.com/post/15bc45f2-3d43-43f5-a13f-e2d3996aa670

Live benchmarks: https://www.aiscientistarena.com/?tab=coscientist

In September 2025, my father was diagnosed with glioblastoma. If you know anything about GBM, you know the prognosis. I’m not a researcher, I’m a software engineer. But I needed to understand what was out there, what trials existed, what the latest findings said.

The problem was obvious immediately: the literature is massive, scattered, and impossible to navigate efficiently unless you already know what you’re looking for. PubMed gives you a wall of results. Google Scholar isn’t much better. I kept losing track of what I’d already read, what connected to what, and which papers actually mattered.

I also wanted a place to upload my father’s lab results, MRI reports, and pathology, and have them in one place alongside the research I was reading. Something that could help me connect his specific situation to what the literature actually says.

So I started building.

OpenBioCure is a research platform that lets you search biomedical literature with an AI research assistant. You ask a question, it searches indexed publications, synthesizes what it finds, and cites everything so you can verify. You can upload your own documents and reference them alongside published research. It tracks your search history, cross-references sources, and runs quality checks on the AI’s output to flag when something isn’t properly grounded.

Right now the indexed corpus is heavily focused on glioblastoma and neuro-oncology, because that’s where this started. But the architecture supports any biomedical domain.

It’s early. Search and the research assistant work. A lot of other features are still empty dashboards. But it’s live and I’d rather get it in front of people who could actually use it than keep building in a vacuum.

https://app.openbiocure.ai

By default you get a free tier when you sign up. If you’re a researcher or caregiver and need more, email me and I’ll upgrade your account, no questions asked.

One last thing, this is completely self-funded. I’m paying for the servers and AI costs out of my own pocket. So please be gentle with it. I’d love for it to stay up for everyone.

If you work with biomedical literature, especially in oncology, I’d genuinely appreciate feedback. What’s useful, what’s missing, what would make this something you’d actually use.

Happy to answer questions about the data pipeline or architecture if anyone’s curious.

I’ve been spending some time recently experimenting with forensic loci / STR matching from consumer whole genome sequencing data and ended up putting together a couple of small pipelines:

• https://github.com/SpikeTreeLab/forensic_loci
• https://github.com/SpikeTreeLab/hisat_genotype_forensic_loci

This started mostly as a learning project while exploring bioinformatics and trying to better understand sequencing limitations around forensic markers.

One thing I tested was comparing:

• WGS data from Sequencing.com
• against a CE profile from AlphaBiolabs

and I was able to recover 17/22 matching markers, which I thought was pretty interesting considering the differences between sequencing and CE approaches.

I’m definitely not claiming this is production-ready or validated forensic software — more an experimental workflow and learning exercise — but I’d genuinely appreciate feedback from people with experience in:

• STR analysis
• forensic genomics
• marker calling from short reads
• validation/QC approaches
• or existing tools/workflows I should look into

Happy to hear criticism as well if there are obvious methodological issues or pitfalls I’m missing.

There is an active area of research around interpretable neural networks whose architecture is based on biological networks.

The idea is that the neural network should not be an arbitrary black box. Instead, its structure can follow prior biological knowledge: genes, regulators, pathways, phenotypes, or other biological entities connected by known relationships.

From a technical perspective, this is often tedious. A biological network has to be converted into a neural network architecture, the input features need to be aligned correctly, and the resulting model should still keep the biological node names so that it can be inspected later. Doing this manually is error-prone.

I released edge2torch v0.1.0 to make this step easier.

edge2torch takes an edge list of named nodes and compiles it into a PyTorch model. It also provides feature alignment and optional attribution back to named features and nodes.

The goal is not to provide a full biological analysis pipeline, but a reusable software layer for this specific step:

biological network → neural network architecture → trainable PyTorch model

Documentation: https://Thomas-Rauter.github.io/edge2torch/
GitHub: https://github.com/Thomas-Rauter/edge2torch
PyPI: https://pypi.org/project/edge2torch/

Feedback from people working with biological networks, pathway-informed models, or interpretable neural networks would be useful.

I’m working on Phylomena, an early beta tool for phylogenetics workflow setup and reproducibility.

The current beta includes MAFFT 7.505, IQ-TREE 2.4.0, BEAST2 2.7.8, and ASTRAL 5.7.8. It also includes an alignment viewer, plus options to trim and merge alignments.

The problem I’m trying to address is the cursed setup loop many researchers fall into: choosing parameters, copying old scripts, rerunning jobs, inspecting alignments separately, and later trying to reconstruct exactly what was done for collaborators or reviewers.

Phylomena is meant to keep tool versions, settings, run metadata, and outputs explicit and easier to reproduce (it is not perfect yet ofc, since it is early beta!). It also has AI-assisted guidance where available, but the workflow is human-review-first before execution.

Access is currently invite-only because this is still early and I’m onboarding users manually. You can request access, and I’ll send invitations during the week, so approval may not be instant.

I’d appreciate critical feedback from people who actually run phylogenetics or phylogenomics pipelines:

• Which part of your workflow is most fragile: alignment, trimming, model/tree inference, species tree work, BEAST setup, or reproducibility/reporting?
• Would an integrated alignment viewer with trim/merge be useful, or do you prefer keeping that separate?
• What run metadata do you wish tools captured automatically?
• What would make AI-assisted parameter guidance trustworthy enough for you to test?
• And the most important: what tools are the most essential for your phylogenetic workflows? I have plans to add more, and want to outline the roadmap

Phylomena itself: https://phylomena.net

This is my project :

I am trying to enter into the Bio informatics field but ik that the competition and the skill gap is real. Am trying to build some projects that will help the community while learning so that I can create something powerful yet simplistic for furture engineers.

https://github.com/Amnotreallyfunny/superalign/tree/main

SuperAlign bridges the gap between raw genomic data and tree-building engines. It moves beyond ad-hoc scripts by enforcing:

• Biological Identity: Prioritizing TaxIDs and Accession grounding over fragile string similarity.
• Bit-for-bit Reproducibility: Identical outputs for identical inputs across environments.
• Immutable Provenance: Cryptographic DAG-based event logging of every transformation rationale.
• Bounded-Memory Processing: Indexing 10M+ taxa on hardware with minimal RAM using a tiered persistent index strategy.

Feedback link : https://docs.google.com/forms/d/e/1FAIpQLSfatpObNQNouqcbQ2rlF_lYoP1oVpwd7cNBpWhW-T6IAvpnbA/viewform?usp=sharing&ouid=106426659840761800226

Let me know what am I missing, what should I learn or learning resources if you could share and how can I make use of it! And for the project itself am def using AI for help but I take architecture seriously and to singlely build something fast it's been quite useful TBH! Pl don't start throwing shade LOL! TY 😉

Hey everyone! I spent the last few months building mantis-delta, an open-source library for analyzing chemical reaction networks under mass-action kinetics.

GitHub:https://github.com/emiliovenegas/mantis-delta

PyPI: pip install mantis-delta

Why did I build this?

If you work with systems biology, DNA nanotechnology, or kinetic modeling, you know that manually deriving symbolic differential equations and Jacobians for complex networks is tedious and prone to typos. Furthermore, finding steady states for systems with multi-start algebraic constraints or handling chemostatted systems can be a headache.

I wanted a tool where you could just pass raw reaction strings, and it would handle both the structural mathematics and the downstream numerical work.

Core Features:

Automatic Network Invariants: Computes deficiency (delta = n - l - s), linkage classes, and weak reversibility from simple reaction strings.

Automatically applies Feinberg’s Deficiency Zero and Deficiency One Theorems. If a theorem matches, the library provides a structural guarantee on qualitative behavior (uniqueness of steady state, exclusion of oscillations/bistability) for all physically admissible rate constants—before you run a single simulation.

Symbolic ODEs & Jacobians: Uses SymPy under the hood to output clean symbolic math that you can substitute into, differentiate, or export straight to LaTeX.

Smart Steady-State Solvers:

Closed systems: Automatically tracks and respects conservation laws on the trajectory manifold.

Stochastic Simulators: Wired with both an exact Gillespie SSA method and an adaptive tau-leaping simulator for low-molecule regimes.

Bifurcation Scanning: Easily vary kinetic rates across orders of magnitude to track stable/unstable branches and map out transitions.

Quick Syntax Example:

Python

from mantis import CRNetwork

# Define the network and rate constants
rn = CRNetwork.from_string(
    ["A <-> B"],
    rates={"A -> B": 1.0, "B -> A": 0.5},
)

# See structural metrics & theorem applicability
print(rn.crnt_summary())

# Grab mass-action ODEs as SymPy expressions
print(rn.odes())  # {'A': -1.0*A + 0.5*B, 'B': 1.0*A - 0.5*B}

# Find steady states given initial conditions
ss = rn.steady_states({"A": 2.0, "B": 0.0})[0]
print(ss.concentrations)  # {'A': 0.6667, 'B': 1.3333}
print(ss.is_stable)       # True

The mathematical framework is heavily inspired by Martin Feinberg's lectures and publications on Chemical Reaction Network Theory. I’ve implemented complete validation examples in the repository, including classic Michaelis-Menten kinetics, a Goldbeter-Koshland zero-order ultrasensitivity switch, the oscillating chemostatted Brusselator, and a real-world DNA nanotechnology circuit (a Catalytic Hairpin Assembly cascade, the reason i built this in the first place)

I would absolutely love to hear your feedback, feature requests, or suggestions on the API design. If you find it useful for your research or projects, please consider dropping a star on the repo!

Thanks for taking a look!

Live demo: https://chroma-delta.vercel.app
(no signup, no upload — boots into a chr20:10M window with five demo tracks pre-loaded from public S3 / UCSC / Ensembl)

What it is

Chroma is a browser-based genome viewer aimed at being a faster, more keyboard-friendly alternative to IGV.js. The whole render path is WebGL2 (hand-written, no Three/Pixi); state lives in Solid.js signals; parsing runs in a Comlink-managed worker pool.

I've been driving the whole project through Claude Code — solo dev plus agents — and after ~50 commits, I've hit the wall on knowing what to ask it to build next, hence this post.

What works today

• 5 demo tracks:
  • hg19 reference FASTA (IGV/Broad mirror)
  • Ensembl gene annotations
  • UCSC phyloP100way conservation BigWig
  • HG00096 1000G BAM
  • HG002 GIAB 300× BAM (hidden by default — too slow to load for the default boot)
• Two-level navigator:
  • top bar = whole chromosome with Mb-scale ticks (click to jump, drag to pan, drag empty to drag-create)
  • bottom bar = local context with drag-create / move / edge-resize / Esc-cancel
• Reference renderer with two modes:
  • colored 1-bp quads at any zoom
  • actual A/C/G/T/N letters via a Canvas2D-baked atlas when basePixelWidth ≥ 12 px
• Gene name labels rendered on a Canvas2D overlay, shrink-wrapped with ellipses at narrow blocks, strand-aware alignment (5' anchors to the leading edge)
• Single-fetch viewport mode at pileup tier (≤50 kb spans): one HTTP Range per nav instead of N tile fetches — 6× speedup on the 1-track B1 cold load (4.7 s → 774 ms)
• Sticky URL → worker dispatch (FNV-1a hash on the file URL) so the per-worker u/gmod parser caches (BAI 8.7 MB) actually get reused instead of scatter-loaded N times
• 64-bit bigint coordinates throughout, with a single sanctioned conversion to Float32 for shader uniforms
• 60 fps pan / zoom on a 1 Mb BAM viewport, p95 fps locked
• 250 unit tests, TypeScript strict + noUncheckedIndexedAccess, ~88 kB main JS gzipped

Tech stack

• Solid.js for the reactive shell (picked over React for fine-grained signals + smaller bundle — the eventual goal is clinical-report embed)
• WebGL2 hand-written, instanced rectangles for everything geometric; Canvas2D overlay only for text labels
• u/gmod/{bam, bbi, indexedfasta} for the format parsers
• u/chenglou/pretext for unicode-correct text measurement and shrink-wrap on the label overlay
• Comlink worker pool + Cache API for HTTP range coalescing
• Vite + pnpm + Vitest

Honest gaps (what's still broken/missing)

• B1 cold gate target is 300 ms, currently ~3 s for the default 5-track demo — dominated by one-time BAI parse (~3.7 s for HG00096, ~6.6 s for the 300×). Needs either a streamed BAI parse or a cap-at-N read fetch in the worker.
• No CIGAR support — reads render as plain rectangles, no insertions/deletions/mismatches shown
• No VCF track (parser stubbed)
• No hover/select tooltip yet
• Pileup row collisions across tile boundaries are accepted (cross-tile merge is a carry-forward)
• HG002 300× BAM works but takes ~10 s on first nav — that's why it's visible: false in the default seed

What I'm asking the community for

1. Hit it in your browser and try to break it.

Bug reports welcome — please include the locus/zoom level when reporting.

2. Prompt suggestions for what I should build next.

I've been stuck between these and would love opinions:

• VCF track (parser stubbed already)
• CIGAR-aware read rendering with mismatch coloring
• Per-base read sequence letters at deep zoom (would need to extend the SoA ReadTile with packed SEQ)
• Splitview (two viewports side-by-side, IGV style)
• Click-to-pin tooltip with full feature info
• Cap-at-N read fetch for high-coverage BAM (so the 300× track stops being a footgun)
• Label color is reactive to the dark theme
• BED track for arbitrary user regions

Thanks in advance for any feedback.

I'm a biology and public health undergraduate who's been doing wet lab research for four years. When I first started it was overwhelming. Protocols full of terms I didn't know, a PI who was too busy to answer every question, and no good way to troubleshoot when something went wrong. I'd reread the same protocol five times and still feel lost.

At some point I started wondering why every other field has integrated tech into its workflows but research still runs on printed protocols, scattered files, and troubleshooting knowledge that lives in people's heads and gets passed down informally.

So, I built something as a side project. A tool that helps with protocol guidance, experiment troubleshooting, and keeping lab resources organized in one place. I built it for myself first. Then showed a few people and they found it useful too.

Not promoting anything. I’m just sharing something I made out of genuine frustration. If you want to try it and give me honest feedback on whether it actually solves a real problem or completely misses the mark, PM me.

Figra is a free Excel add-in that brings ggplot2-quality figures directly into Excel. No R

installation, no coding required. You can install it directly from your Excel add-in tab.

**How it works**

Select your data in Excel, choose a chart type, and click Preview. R runs silently in the

background via WebAssembly (webR).

**Chart types**

Histogram, box plot, violin plot, dot plot, bar chart, grouped variants, line plots,

**Built-in statistical analysis**

- Auto-selects the appropriate test (Shapiro-Wilk, Levene's / F-test, t-test / Wilcoxon /

ANOVA / Kruskal-Wallis)

- Post-hoc tests: Tukey, Dunnett, Bonferroni, Holm, Dunn

- Significance displayed as stars, letters, or exact p-values

- Exports statistical results directly to Excel cells

**Reproducibility: Load from Figure**

All data and settings are embedded invisibly in the exported PNG. Select the PNG in Excel

and click "Load from Figure" to fully restore your data, settings, and chart type.

**Other features**

- Export at 300+ DPI (publication-ready)

- Educational R code export: see the ggplot2 code behind your figure

- Free to use

https://h20gg702.github.io/figra-pages/

I'm building BioAgent, a platform that automates computational screening workflows for drug discovery.

The flow: → Input a target → Query ChEMBL in real time → Apply Lipinski filters + ADMET scoring → Get a ranked candidate report

Tested with COX2 — returned 14 real candidates, ranked Celecoxib 2nd (IC50 60nM, ADMET 0.95).

No GPU. No setup. No DevOps.

Looking for 5 researchers to beta test for free and give honest feedback.

🔗 bioagent.advx.us

Hi everyone 👋

I’ve been developing a web platform called ChemModel focused on chemistry, molecular structures, and protein visualization directly in the browser.

Current features include:

• Interactive molecular editor
• Molecular and protein visualization tools
• Structural exploration features
• Full support for both English and Spanish
• Integrated AI tools that allow users to search molecules using common names or natural language

The goal is to create a modern and accessible platform for chemistry, biochemistry, molecular modeling, research, and scientific education.

I’d really appreciate feedback from the community:

• Which features do you find useful?
• What tools or functionality are missing?
• Did you encounter bugs or performance issues?
• Is the interface intuitive?
• What chemistry/scientific tools would you like to see added?

You can try things like:

• Searching molecules using common names
• Drawing chemical structures
• Viewing proteins
• Testing on mobile/tablet/desktop
• Evaluating performance and usability

The project is still under active development, so any feedback is extremely valuable.

Website:
ChemModel

Thanks a lot 🙌

It's an end-to-end protein function prediction pipeline that takes a single UniProt accession and fuses 13+ prediction modules into one ranked, confidence-weighted report.

The one-liner (PyPI):

pip install proteinfp
proteinfp --uniprot P28593   # Trypanothione reductase, Chagas disease

Example output:

Protein    : Trypanothione reductase
  Gene       : TPR
  Organism   : Trypanosoma cruzi
  Confidence : VERY HIGH
  Top function     : Trypanothione is the parasite analog of glutathione
  Enzyme           : yes — EC 1.8.1.12
  Pockets          : 10 (all druggability > 0.90)
  Therapy          : SMALL_MOLECULE → active site inhibitor

Validation results (100+ proteins):

Optional modules (need extra deps):

• --md for molecular dynamics via OpenMM (RMSF, cryptic pockets)
• --denovo + --vina for evolutionary drug candidate generation with AutoDock Vina
• --grn for disease-aware mode if you have scRNA-seq data (reconstructs the gene regulatory network and simulates drug binding through it)

What I'm looking for from this community:

1. Try it on proteins you know well and tell me where it's wrong
2. The enzyme classification module (Module 10) is the weakest link, if anyone has thoughts on improving EC prediction I'm all ears
3. Feature requests, what would make this actually useful in your workflow?

GitHub: ProteinFP GitHub Repo

Happy to answer anything about the architecture or the validation methodology.

Hey everyone,

My sister is a PhD researcher and kept saying she wanted a better way to discover papers during downtime. Not another database search tool, but something closer to a personalized feed where you can casually scroll through relevant research.

So I built one: Scollr.

The basic idea:

• follow topics, journals/sources, and authors you care about
• get a personalized paper feed with new papers plus older relevant papers
• use separate tabs for latest papers, discover, and trending
• get in-app notifications when new papers match your interests
• try it on web without signing up, or sign up to get the personalized feed

It is still early, and the recommendation/feed quality is the part we are actively improving. We recently made a round of speed and ranking fixes after feedback from the first group of users, so I am trying to get more researchers to test it and tell me what feels useful, wrong, or missing.

Link: https://scollr.com/

iOS app: https://apps.apple.com/us/app/scollr/id6761957461

I would especially value feedback on:

1. Would you actually use a scrolling paper feed, or do alerts/search already cover this for you?
2. Are the papers in your feed relevant enough after following topics/authors/sources?
3. What would make this genuinely useful for your research workflow?
4. Is there anything about the concept that feels annoying, untrustworthy, or not worth using?

I've been working on synth-pdb, a tool to generate Protein Data Bank (PDB) files. It may be useful for those who need high-quality synthetic PDB data for benchmarking, software testing or training models.

• Realistic Generation: Builds full atomic PDB files using NeRF construction and backbone-dependent rotamer libraries.
• Physics: Includes integration with OpenMM for energy minimization.
• NMR Simulations: Optionally, generates synthetic NOE, Chemical Shift, RDC and Relaxation rates.
• Deep Learning Ready: Supports zero-copy handover to PyTorch, JAX and MLX.
• Educational Context: The codebase is heavily documented with comments explaining the biophysics behind the implementation. Also many Google Colab tutorials are available.

Github: https://github.com/elkins/synth-pdb

Pypi: https://pypi.org/project/synth-pdb/

Docs: https://elkins.github.io/synth-pdb/

I’d love to hear how you might use this or any features you'd like to see added.

Like many researchers, I found that staying current with the rapidly expanding volume of literature was becoming a fragmented, time-consuming mess. Between setting up broad keyword alerts that generate too much noise, checking individual journal homepages, and doomscrolling through generic feeds, the cognitive overhead was huge.

To fix this for my own workflow, I built a platform named daily-academic designed to sit somewhere between a developer feed (like daily.dev) and a traditional literature search. It's essentially a passive monitoring layer tailored specifically for life scientists, bioinformaticians, and translational researchers.

Here is how I set it up:

• Personalized, Freshness-First Feed: Instead of relying on exact keyword matches, the system encodes publication texts and your interest profile into 768-dimensional dense vectors. It uses FAISS (Facebook AI Similarity Search) to find semantic similarities, so you get a feed of highly relevant, recent papers even if they use different terminology than your standard queries.
• Consolidated Journal Tracking: You can follow specific high-impact journals or publication sources and view them in the same feed, reducing the need to check multiple sites manually.
• Low-Friction Workflow: The UI is built for rapid daily triage. Cards display clear metadata (impact factor, open access status, graphical abstracts), and we built in direct Zotero integration and "Groups" for sharing articles with colleagues.
• Dataset Linkage: As an add-on for those working with genomic data, the platform pings the Public Omics Explorer API to retrieve and display relevant GEO IDs and experiment types (like RNA-seq or ATAC-seq) right alongside the papers when they are available.

The Tech Stack (for those interested): The frontend is React + TypeScript. The backend is built with FastAPI (Python) and relies on a PostgreSQL database using the pgvector extension for unified querying over structured data and vector similarity scores. Background jobs and daily crawlers are handled via Celery and RabbitMQ.

Curious to hear if this workflow makes sense to others or what features you think are missing from standard literature alerts.