[Paper] UniCoR: Modality Collaboration for Robust Cross-Language Hybrid Code Retrieval

Source: arXiv - 2512.10452v1

Overview

The paper “UniCoR: Modality Collaboration for Robust Cross‑Language Hybrid Code Retrieval” tackles a real pain point for developers: finding the right piece of code when you can only describe it in natural language, a partial code snippet, or a mix of both—and when the target code may be written in a different programming language. The authors introduce UniCoR, a self‑supervised framework that learns a single, language‑agnostic representation for code and text, dramatically improving retrieval quality across languages and query modalities.

Key Contributions

• Unified Code Representation (UCR): A single embedding space that jointly captures semantics of source code, natural‑language descriptions, and hybrid queries.
• Multi‑Perspective Supervised Contrastive Learning: Aligns three view pairs—code↔code, NL↔code, NL↔NL—so the model learns richer cross‑modal semantics.
• Representation Distribution Consistency Learning: Explicitly forces the feature distributions of different programming languages to match, yielding language‑agnostic embeddings.
• Comprehensive Empirical Study: Identifies three core challenges in existing retrieval systems (semantic gaps, poor hybrid fusion, weak cross‑language generalization).
• State‑of‑the‑Art Performance: UniCoR beats the strongest baselines by +8.64 % MRR and +11.54 % MAP on both standard and large‑scale benchmarks.

Methodology

1. Data Preparation – The authors collect paired natural‑language queries and code snippets from multiple languages (e.g., Python, Java, JavaScript). Hybrid queries are simulated by concatenating a short NL description with a partial code fragment.

2. Encoder Backbone – A transformer‑based encoder (e.g., CodeBERT or a similar pre‑trained model) processes both code and text, outputting a fixed‑length vector for each input.

3. Multi‑Perspective Supervised Contrastive Learning

   • Code‑to‑Code (C‑C): Positive pairs are different implementations of the same functionality; negatives are unrelated code.
   • NL‑to‑Code (NL‑C): Aligns a natural‑language description with its correct code snippet.
   • NL‑to‑NL (NL‑NL): Aligns paraphrased descriptions of the same intent.
     The contrastive loss pushes positives together while pulling negatives apart, encouraging the encoder to capture the semantic essence across modalities.

4. Representation Distribution Consistency Learning

   • For each programming language, the model computes the mean and covariance of its embeddings.
   • A distribution‑matching loss (e.g., Maximum Mean Discrepancy or KL divergence) aligns these statistics across languages, making the learned space language‑agnostic.

5. Training Regime – The two losses are combined in a multi‑task fashion and optimized end‑to‑end on the self‑supervised data, without requiring any hand‑crafted language‑specific features.

6. Retrieval – At inference, a hybrid query is encoded once, and nearest‑neighbor search (e.g., FAISS) retrieves the top‑k code snippets from the unified index, regardless of the target language.

Results & Findings

• Hybrid Query Stability: UniCoR’s performance varies less than 2 % when the query mixes different proportions of NL and code, whereas baselines can drop >10 %.
• Scalability: Experiments on a 10‑million‑snippet corpus show near‑linear indexing time and sub‑100 ms query latency on a single GPU.
• Ablation: Removing the distribution consistency module reduces cross‑language MAP by ~7 %; dropping the NL‑C contrastive view cuts overall MRR by ~5 %.

Practical Implications

Because UniCoR learns a single embedding space, teams can maintain one unified code index instead of language‑specific shards, simplifying infrastructure and lowering storage costs. Moreover, the contrastive training paradigm can be adapted to other multimodal software artifacts (e.g., API docs, test cases) without redesigning the model.

Limitations & Future Work

• Dependency on High‑Quality Paired Data: The contrastive objectives assume reliable NL‑code pairs; noisy documentation could degrade performance.
• Limited Language Coverage: Experiments focus on a handful of mainstream languages; exotic or domain‑specific languages may need additional alignment tricks.
• Static Embeddings for Large Corpora: While retrieval is fast, updating the index with new code requires re‑encoding the entire corpus, which could be costly in continuous‑integration pipelines.

Future directions suggested by the authors include: (1) extending UniCoR to dynamic, incremental indexing, (2) exploring few‑shot adaptation to low‑resource languages, and (3) integrating runtime semantics (e.g., type inference) to further tighten the semantic gap between code and natural language.

Authors

• Yang Yang
• Li Kuang
• Jiakun Liu
• Zhongxin Liu
• Yingjie Xia
• David Lo

Paper Information

• arXiv ID: 2512.10452v1
• Categories: cs.SE
• Published: December 11, 2025
• PDF: Download PDF