Research Award Opportunities
One of the most valuable research experiences for an undergraduate student is to be a research assistant. Each year, the department receives a number of research awards that help provide funding for an undergrad student to spend 16 weeks over the summer working full time in one of the department’s research labs, often with the opportunity to publish their work (see examples of previous projects.) This kind of research experience is highly sought after by graduate programs.
All applicants must confirm their eligibility to apply and to work. You must have all necessary requirements prepared (ex. Social Insurance Number and permits).
International students must have a valid Social Insurance Number and be eligible to work on campus for the duration of the award (ex. in the summer). you will be required to provide any necessary details and documentation upon accepting the award (SURE or WLIUR). This is necessary for processing and payment. If you are offered an award but do not meet this criteria, you will not be able to accept. For questions about eligibility, please speak with an International Student Advisor.
Award Categories
The positions are available to 2nd, 3rd, and 4th year students with strong academic records. You'll find more information about the awards available, including eligibility requirements below. Watch for in-class and email announcements from the department for details and deadlines.
NSERC USRA
NSERC Undergraduate Student Research Award
SURE
Science Undergraduate Research Experience Award
WL IURA
Work Learn International Undergraduate Research Award
Work Learn International Undergraduate Research Award Science Blog
Additional Resources
Eligible UBC Grant Holders in the Faculty of Science for NSERC USRA 2026 - 2027
USRA Form 202 Checklist for Common Errors 2026-27
USRA Form 202 Checks for Completeness 2026-27
How to Apply
Deadline: February 6, 2026 at 4:00 PM
New Application Requirement: all applicants are required to apply with a confirmed supervisor. The list of projects and supervisors will be posted on this page, and you can use this to approach any of the supervisors listed. However, you aren't limited to the projects and supervisors listed below. We encourage you to directly contact professors you would like to work with to find a match. Many professors will be happy to talk to you about the opportunity to hire students at a subsidized wage. You can find our faculty directory here. For some additional tips, please see the UBC Careers page.
Required Steps:
- Read the details above and the information at the links on this page
- Determine which awards you are eligible for
- Contact potential supervisors from the Projects and Supervisors list (see below) or by approaching Computer Science faculty members you would like to work with
- Once you have a confirmed supervisor, submit the online application webform by the stated deadline (the webform will become available before the deadline):
- Before submitting, please ensure that you have read over the online guidelines, eligibility requirements, and webform instructions carefully
- Make sure to read all of the instruction text in the webform, there may be important details noted below each field
- When the department is informed of how many awards are available, a departmental adjudication committee will rank the applications based primarily on the student's academic record. All applicants will then receive a decision. If you are selected for an award, you will then receive an email with instructions to submit a new webform to provide additional information/documentation:
- When you are applying: please read the webform carefully to ensure you are prepared to accept by providing these details
- (Your supervisor will also be contacted for required information)
APPLY HERE - NSERC / SURE / WL IURA Application Webform
IMPORTANT:
- All students should complete the NSERC Form 202 on the NSERC USRA website by clicking "On-line System Login" or, if you are a first-time user, "Register"
- All students should upload a PDF of the completed NSERC Form 202 to the online application webform
- DO NOT submit the application on the NSERC website until you have been accepted for the award and instructed to do so (at the end only students awarded for NSERC USRA will submit the application to NSERC website)
- Instructions on how to complete the forms can be found on the NSERC USRA website
Questions? For further details, please visit the UBC Student Services website or the NSERC USRA website and review the information and links provided, as these will likely give you the answers to your questions. If you would still like additional assistance, please see our Advising Webform instructions to see if you are eligible to submit a webform request.
Projects and Supervisors: Summer 2026
Project 1: Protecting Confidential Cloud Applications from Controlled-channel Attacks with User-level Paging
Students interested in participating in this project should email their most recent CV and academic transcripts, CC’ing both Professor Aastha Mehta (aasthakm@cs.ubc.ca) and Kha Dinh (dalo2903@gmail.com).
Research Outline:
Confidential Virtual Machines (CVMs) protect entire application environments from compromised cloud platforms. However, protected applications remain vulnerable to side-channel leakages arising from resource access patterns during computation. Specifically, side-channel attacks such as cache-timing and controlled-channel attacks have been shown to expose these access patterns and reveal critical secrets. A practical approach to mitigating these leakages without significantly changing the existing infrastructures is to transform an application's resource accesses into secure ones that do not reveal sensitive information. This technique is also known as obfuscation. Unfortunately, existing obfuscation approaches often require extensive software rewrites or specialized compilers, which limit their applicability and create significant engineering and performance overhead.
This project investigates custom user-level paging policies as a practical obfuscation mechanism. User-level paging allows applications to define their own memory management strategies without OS modifications, granting page-level control over when and where memory accesses are performed. By leveraging this control for obfuscation, the approach maintains compatibility with existing workloads while minimizing the engineering effort required to adapt new workloads.
The expected outcome of the project is a practical and portable obfuscation framework based on user-level paging that can be applied to unmodified or minimally modified applications running inside CVMs. The project will deliver a working prototype, an evaluation of its effectiveness, and overhead on representative cloud workloads. It will also produce reusable insights into applying user-level paging as a defense against side-channel attacks.
Student Responsibilities:
The student will meet the project group weekly and produce weekly reports to track the research progress. The student will participate in these four steps:
- First, the student will implement a prototype for memory access obfuscation onto well-known interfaces like Linux's userfaultfd, using obfuscation techniques like Oblivious RAM (ORAM).
- Second, the student will apply the prototype of the system to common cloud workloads, such as web servers and machine learning.
- Third, the student will measure the system's performance impacts. This requires the student to set up a stable evaluation environment and write reusable evaluation scripts.
- Finally, based on the performance evaluation, the student will explore strategies to reduce the overhead that is expected to be high. At the mechanism level, this involves optimizing the user-level paging mechanism. At the policy level, this involves investigating principled trade-offs between security and performance through algorithmic design choices.
Qualification:
Students interested in working on this project must have done CPSC 213 and CPSC 313, and be proficient in C/C++. Prior experience with kernel programming (e.g., CPSC 436A and SPSC 508) is desirable but not a requirement.
Work Setting:
On-site (UBC Vancouver Campus)
Project 2: TEE-assisted attestation for processing-in-memory cores
Interested students should send an email to Aastha Mehta (aasthakm@cs.ubc.ca) and Peterson Yuhala (peterson.yuhala@unine.ch).
Research Outline:
Processing-in-memory (PIM) is an emerging computing paradigm that augments memory with computation capability via low-power compute cores called DRAM processing units (DPUs). This reduces the data movement overhead in traditional processor-centric designs for memory intensive workloads like machine learning. However, current PIM-based architectures are still at their infancy and lack mechanisms to ensure data confidentiality or to authenticate PIM compute cores via mechanisms like remote attestation. CPU-based trusted execution environments (TEEs) like Intel SGX provide these security guarantees for processor-centric architectures, but do not extend this security to accelerators like DPUs. The goal of this work is to design and implement a TEE-based PIM-DPU attestation module using Intel SGX. TEE-based PIM applications will send DPU attestation requests to this module to authenticate DPUs, after which secure data transfers can be done with the DPU. The results of this work will allow a PIM security architecture to be co-designed with a CPU TEE.
Student Responsibilities:
The project includes the following tasks:
- Get familiar with building SGX-based programs using tools like Gramine (https://gramine.readthedocs.io/en/stable/run-sample-application.html) and TEE attestation mechanisms.
- Porting a simple PIM host application (see https://github.com/CMU-SAFARI/prim-benchmarks/tree/main/VA) to SGX using Gramine
- Developing an SGX-based attestation module using Gramine. This module will receive DPU attestation requests from PIM host applications, authenticate the DPUs, and create secure communication channels with the DPUs for exchanging data (e.g., via a Diffie-Hellman key exchange)
- As current PIM DPUs do not have support for attestation, the DPU-side attestation logic will be simulated in a C/C++ based application. It will comprise cryptographic keys (i.e., a public and private key pair) used for attestation and establishing the secure communication channel with the attestation module.
- Since DPUs are very lightweight compute cores, an attestation design where DPUs are verified in groups (rather than individually) will be investigated.
- Evaluating the overhead of the TEE-assisted DPU attestation mechanism
- Summarizing the results of the project in the form of an end-of-term report and a presentation in the lab.
- The results of this work will be integrated with a PIM DPU simulator extension to achieve a complete TEE-enabled PIM security architecture.
Qualification:
Students interested in this project must have done CPSC 213, CPSC 313 and be proficient in C/C++. Basic knowledge of cryptography is desirable but not essential. Having taken Courses CPSC 436A and/or 436S is the preferred background, but are not mandatory. Prior experience with kernel programming, hardware-based security (e.g., CPU TEEs), and version control systems (e.g., Git) is a plus, but not a requirement.
Work Setting:
On-site (UBC Vancouver Campus)
Project 1: Improving Rust Analysis Tools
To apply, please contact the lead PhD student, Zack Grannan <zgrannan@cs.ubc.ca>.
Research Outline:
The Rust programming language has enjoyed increasing real-world adoption over recent years. Much of its success can be attributed to its ability to provide low-level control while simultaneously ensuring memory safety. Rust achieves these seemingly incompatible goals by employing a sophisticated type system that incorporates notions of ownership and borrowing to ensure the absence of memory errors such as dangling pointers and buffer overflows.
Many tools that analyse Rust programs reason about the ownership and borrowing guarantees that are enforced by Rust's type system. For example, program verifiers such as Prusti exploit these guarantees to automatically synthesise proofs to reflect the aliasing restrictions enforced by Rust's type system. Unfortunately, due to the complexity of Rust's ownership and borrowing model, automatically extracting these guarantees from a Rust program is not straightforward. As a result, many tools develop their own ad-hoc models that support only a limited subset of the Rust language.
Recently, we have developed a model of Rust's ownership and borrowing called Place Capability Graphs (PCGs) that can be used by Rust analysis tools to automatically extract these guarantees from a Rust program. For example, we updated the Prusti program verifier to use the PCG instead of its previous ad-hoc analysis. By adopting the PCG, Prusti can now support more Rust programs, for example, those that perform borrowing operations inside loops.
In this project, you will evaluate the applicability of the PCG to other analysis tools by integrating it into the program visualisation tool RustViz. RustViz, a tool developed at the University of Michigan, is designed to help users understand Rust's ownership and borrowing by generating visualisations of Rust programs. However, one significant limitation of the tool is that it requires the user to manually add annotations to the Rust code that describe borrow-checking related events (such as the points in the program where borrows expire). In this project, you will update the RustViz tool to instead query the PCG to automatically extract these events, thereby enabling it to automatically generate visualisations without relying on user-provided annotations.
If time permits, this project will also explore integrating the PCG into other Rust analysis tools.
This project will provide exposure to a collaborative research environment and an opportunity to gain experience developing real-world program analysis tools. In addition, the project will allow you to deeply explore the Rust programming language, type system, and implementation. During the project, you will work closely with other students involved in the development of the PCG model and other related projects such as the Prusti program verifier. This project is suitable for students who have strong implementation skills and are comfortable working with existing real-world codebases independently. Previous research experience is not required.
Student Responsibilities:
You will be responsible for designing and implementing an integration of the PCG model with the RustViz visualisation tool, with the goal of enabling it to generate visualizations automatically (eliminating the need for user-provided annotations). You will be expected to develop a strong understanding of the PCG and RustViz by reading the relevant papers describing them. Additionally, we expect that you can work independently to understand the Rust implementation of these projects and extend them accordingly. During this project, you will work alongside graduate students involved in the development of the PCG who can provide support in explaining the model design and implementation. You will also have weekly meetings where you will receive guidance and feedback throughout the project.
Qualifications:
Experience with the Rust programming language, familiarity with programming language concepts such as compilers and type systems
Work setting:
On-site (UBC Vancouver Campus)
Project 2: Capabilities-based Verification for Rust Clients of Interior Mutability
To apply, please contact the lead PhD student, Jasper Geer <jasper.geer@ubc.ca>
Research Outline:
Rust is an increasingly popular systems programming language with a type system that provides particularly strong guarantees about program behaviour. These guarantees make Rust particularly amenable to automated program verification using tools like Prusti.
Interior Mutability is a Rust design pattern in which the guarantees of Rust's type system are upheld by careful design of a module rather than the static analysis performed by the type checker. Interior-mutable modules enable patterns such as mutable aliasing which the type checker would otherwise prohibit. However, this added flexibility makes clients of interior-mutable modules more difficult to verify.
In this project, you will be working on a new prototype implementation of Mendel, a technique for verifying clients of interior-mutable modules. Mendel reasons about interior mutability using "implicit capabilities", which describe the access permissions granted by the design of module APIs. This prototype verifier will make use of the PCG, a state-of-the-art model of the Rust compiler's type checking results.
Student Responsibilities:
Work closely with a PhD student to design and implement a prototype verifier for Mendel which encodes verification problems as programs in the Viper intermediate verification language. Explore the interaction between Mendel's system of implicit capabilities and the capability information exposed by the PCG analysis.
Qualifications:
Familiarity with the Rust programming language. Some experience writing programs that process other programs, such as interpreters, compilers, or static analyzers. You may have taken CPSC311 or CPSC411, for example.
Work setting:
On-site (UBC Vancouver Campus)
Alex Summers and Ivan Beschastnikh
Project 1: A testing pipeline for the Linux kernel eBPF verifier
To apply, please contact the lead PhD student, Yanze Li <yanzeli@cs.ubc.ca>.
Research Outline:
eBPF is an emerging technique for safely extending OS kernels such as the Linux kernel. The safety of such extensions is guaranteed by a verifier that automatically checks the properties of eBPF programs (e.g., memory safety, termination, etc.). Previous studies show the eBPF verifier contains bugs that accept unsafe extensions, exposing various security vulnerabilities to the kernel.
In this project, students will investigate and build infrastructure for testing and profiling the eBPF verifier in the Linux kernel. The project will facilitate other research projects on enhancing the safety guarantees provided by the eBPF verifier.
Related materials:
“Test Verifier Changes on Cilium's BPF Programs”: https://pchaigno.github.io/ebpf/2025/09/23/test-verifier-changes-on-cilium-bpf-programs.html
Student Responsibilities:
Students will experience membership of a research lab (the Software Practices Lab): they will participate in research activities, develop research prototypes, attend research meetings, and practice presenting their work.
Qualifications:
The students should have some familiarity with C/C++ and their compilation toolchains and CI/CD testing pipelines. Students should be comfortable with hacking on large code bases (i.e. the Linux kernel).
Students should already have taken courses like 310 and 313 or be familiar with the content in these courses.
Work setting:
On-site (UBC Vancouver Campus)
Project 2: Formally verifying abstract domains for arithmetic operations.
To apply, please contact the lead PhD student, Yanze Li <yanzeli@cs.ubc.ca>.
Research Outline:
Abstract interpretation is a technique for automatic reasoning for program properties via statically interpreting programs in abstract domains. Abstract domains for arithmetic operations are useful for detecting bugs like out-of-bound accesses, integer overflow, etc.
In this project, students will model a set of abstract domains for arithmetic operations in a proof assistant and prove their soundness (i.e., the abstract domains approximate all possible behavior at run-time).
If time allows, students will then develop new provably correct algorithms that improves the precision and/or efficiency for these abstract domains, and evaluate them in concrete applications.
Related materials:
“Program Analysis Combining Generalized Bit-Level and Word-Level Abstractions”: https://rainoftime.github.io/files/ISSTA25.pdf
“Sound, Precise, and Fast Abstract Interpretation with Tristate Numbers”: https://people.cs.rutgers.edu/~sn349/papers/cgo-2022.pdf
Student responsibilities:
Students will experience membership of a research lab (the Software Practices Lab): they will participate in research activities, develop research prototypes, attend research meetings, and practice presenting their work.
Qualifications:
Students should be interested in mathematical proofs, theorem provers (e.g., Rocq, Lean, F*...), and reading research papers involving formal math definitions. Students should already have taken courses like 311 or 411 or be familiar with the content in these courses. Students are expected to have some experience in functional programming (e.g. in languages such as OCaml, Haskell, or Racket).
Work setting:
On-site (UBC Vancouver Campus)
Project: Proving Termination for E-matching with Theory-specific Reasoning
To apply, please contact the lead PhD student, Rui Ge <rge@cs.ubc.ca>.
Research Outline:
SMT (satisfiability modulo theories) extends SAT (Boolean satisfiability) to first-order logic with theories (e.g. linear arithmetic). SMT solvers aim to solve SMT problems and form the backbone of many modern program verification tools.
SMT-based program verification often involves axiomatising problem features into SMT solvers as universally quantified formulas, which must be instantiated during SMT solving. A widely used technique for handling quantifiers is E-matching (a.k.a. trigger-based instantiation), whose behaviour is sensitive to trigger choices – poor trigger choices can lead to non-termination.
Recent work (Ge et al., 2024) introduced a formal framework for proving that a provided axiomatisation is guaranteed to terminate under E-matching, and applied it to a set theory axiomatisation without cardinality constraints.
In this project, the student will extend this framework to axiomatisations involving theory-specific reasoning, such as set cardinalities, where termination arguments must account for interaction with theories like linear arithmetic.
Related work:
Ge at al., 2024: A Formal Model to Prove Instantiation Termination for E-matching-Based Axiomatisations
https://doi.org/10.1007/978-3-031-63498-7_25
Student responsibilities:
The student will experience membership of the Software Practices Lab: they will participate in research activities, develop research prototypes, attend research meetings, and practice presenting their work.
Qualifications:
- Comfortable reading and writing discrete mathematics proofs (e.g. induction, proof by contradiction, invariants)
- Interest in formal logic and symbolic reasoning
- Familiarity with first-order logic (as covered in CPSC 121; CPSC 322/422 is a plus)
- Prior exposure to SAT/SMT solving, formal methods or program verification, or experience with theory-heavy or proof-based CPSC courses (e.g. CPSC 320/420, CPSC 421) is nice to have but not required.
Work setting:
On-site (UBC Vancouver Campus)
Project: Convergence of Gradient Methods with Subspace Search
Research Outline:
Gradient descent is one of the simplest and most fundamental algorithms for continuous optimization. Numerous variants, including line search, momentum-based methods, and stochastic updates, are widely used to improve convergence in practice. In theory, accelerated gradient descent is known to achieve optimal convergence guarantees for convex optimization, a result that is also supported empirically.
Despite this, many practical optimization algorithms perform significantly better than what existing theory predicts, leaving a gap between provable guarantees and observed performance. This suggests that incorporating richer update primitives—such as line search, plane search, or more general subspace search—may yield improved convergence guarantees. The goal of this project is to develop rigorous convergence analyses for gradient-based optimization algorithms that incorporate these enhanced variants. The project will investigate both upper and lower bounds on convergence rates, as well as explore new methods that leverage subspace search to achieve improved guarantees for convex optimization.
Student Responsibilities:
- Study gradient descent, accelerated methods, and line/plane search techniques
- Learn lower-bound techniques for convex optimization
- Review research literature on variants with strong empirical performance
- Formalize a framework for analyzing gradient methods with subspace search
- Present progress and results through regular meetings
Qualifications:
Background in linear algebra and calculus, with a strong interest in theoretical computer science and optimization. Willingness to engage deeply with mathematical topics and contribute to proving new theoretical results.
Work Setting:
Combination of remote and on-site (UBC Vancouver Campus) is possible
Project: Evaluating LLM-Based Fuzz Harness Generation
Research Outline:
Fuzzing is a popular automated software testing technique, traditionally used for finding security vulnerabilities. It uses a random search procedure to find inputs that reveal abnormal behavior in the software under test, like crashes.
State-of-the-art fuzzing tools require harnesses to test software libraries. These are hand-crafted code snippets that provide an entry point for the fuzzing tool. Quality harnesses can be difficult to write, so there has been a wave of interest in academia and industry to use LLMs to synthesize these harnesses. However, early results have been mixed. In particular, a synthesized harness might misuse the library (with respect to documented or undocumented constraints), causing false positives.
In this project, you will evaluate existing LLM-driven harness synthesis tools for fuzzing software libraries. You will assess the performance of these tools on libraries of varying sizes and popularity, to find the strengths and limitations of prior work. You will analyze the quality of these synthesized harnesses in terms of false positives, code coverage, and bug finding ability.
Student Responsibilities:
- Explore the current landscape of LLM-driven fuzzing tools (i.e., literature analysis)
- Critically analyze the effectiveness of existing harness synthesis tools
- Identify bottlenecks, edge cases, and recommend improvements
- Write scripts and automation for reproducing the evaluation
Qualifications:
Basic understanding of C or similar low-level programming language. Familiarity with a scripting language for quick prototyping (like JavaScript or Python). CPSC 210 required. CPSC 310/311/410/411 may be of use, but not required. Co-op experience may be of use, but not required.
Work Setting:
On-site (UBC Vancouver Campus)
Remote work ok for some days of the week
Project 1: Measuring Human Facial Expressions
Research Outline:
Human faces communicate a wealth of information in subtle yet powerful ways. We are developing a novel face-capture facility equipped with seven high-speed cameras, eye trackers, and additional sensors to measure facial expressions in detail. To get a sense of the type of data captured—though not all project details or goals—see:
https://tobias-kirschstein.github.io/nersemble/
Student Responsibilities:
Collect high-quality data with human participants and learn facial expression models from this data.
Qualifications:
Enjoys interacting with people and conducting experiments. Comfortable working with cutting-edge instrumentation (e.g., machine vision cameras and novel sensors). Some experience with computer vision, computer graphics, or machine learning is a plus. Most importantly, the candidate pays close attention to detail and is committed to collecting the highest-quality data.
Work Setting:
On-site (UBC Vancouver Campus)
Project 2: Real-Time Simulation of Facial Expressions
Research Outline:
Human faces are commonly simulated using blend shapes, which fail to capture the subtle ways skin moves across the face -- especially around the eyes. This project will use facial expression data from our lab and external sources to simulate fine-scale details such as wrinkles, gaze, and dynamics that are essential for crossing the “uncanny valley.”
Student Responsibilities:
Work with graduate students in the lab to (a) simulate skin motion and wrinkling using Eulerian discretizations, and (b) learn data-driven methods for generating facial expressions. Software will be implemented in Python using NVIDIA’s Warp framework for parallel spatial computing.
Qualifications:
A strong passion for real-time computer graphics and animation is required (through coursework and extracurricular activities). Experience with machine learning and physics-based animation is a plus.
Work Setting:
Combination of remote and On-site (UBC Vancouver Campus) is possible
Project: PLAICraft - Embodied AI
** Please submit your application package to plai-admin@cs.ubc.ca **
Research Outline:
What if you could talk to an AI agent in a video game and have it actually understand and interact with you? That's the goal of PLAICraft.
We're building embodied AI agents that can see, listen, and act intelligently in an open-world Minecraft environment. To train these agents, we've created a free, browser-based Minecraft platform where players around the world contribute gameplay data—everything from video and audio to mouse movements and keypresses. This massive dataset helps our researchers develop advanced AI technologies like diffusion models and world modeling, which teach AI to understand how environments work and adapt when things change. Join our team and contribute to cutting-edge AI research while having fun in Minecraft.
Role 1: Data Engineer
Student Responsibilities:
- Develop and maintain data pipeline workflows including transformation, normalization, and quality assurance
- Manage cloud infrastructure configuration to automate data collection and processing
- Monitor data quality metrics, document procedures, and maintain organized datasets
- Support ML data preparation by ensuring data accuracy, consistency, and formatting
Preferred Qualifications:
- Proficiency in Python and familiarity with AWS services (S3, Lambda, DynamoDB, EC2)
- Experience with SQL, PostgreSQL, and understanding of database design concepts
- Knowledge of data formats (CSV, JSON, Parquet) and data transformation techniques
- Experience with Git version control, Docker containerization, or similar tools
Work Setting:
On-site (UBC Vancouver Campus)
Role 2: UI/Game Programmer
Student Responsibilities:
- Design and optimize user interface components for the gameplay website and admin dashboards
- Develop plugins for in-game UI elements, menus, and interactive player features
- Test UI across platforms for performance and usability, debug issues, and document code for maintainability
Preferred Qualifications:
- Proficiency in TypeScript/JavaScript and experience with React or similar web frameworks
- Experience with Java and familiarity with Minecraft plugin ecosystems
- Knowledge of UI/UX design principles, state management, and component-based architecture
- Experience with Git version control, AWS cloud services, or collaborative development environments
Work Setting:
On-site (UBC Vancouver Campus)
Project: Analyzing Attention Patterns in Vision–Language Models for Chart Understanding.
To apply, please contact the lead Postdoctoral Researcher, Mir Rayat Imtiaz Hossain <rayat137@cs.ubc.ca>.
Project Outline:
Vision–Language Models (VLMs) are increasingly used for chart understanding and visual question answering, yet their internal decision-making processes remain largely opaque. This project aims to analyze how attention in VLMs evolves as the model processes prompts and visual inputs, and how these attention patterns compare to human attention when solving the same tasks.
The project will combine techniques from machine learning and information visualization to study temporal attention dynamics, such as how a model’s focus shifts across different regions of a chart as it reads a question and generates an answer. These patterns will be compared with human attention derived from existing human studies, gaze data, or structured annotations.
Time permitting, the project may also explore whether incorporating human attention patterns can improve model performance for chart question answering, or analyze how robust such models are when presented with misleading or deceptive charts. The exact direction will be adapted to the student’s background and interests.
We primarily seek 3rd- or 4th-year undergraduate students. Prior research experience is welcome but not required. This research contributes to improving the interpretability, reliability, and robustness of AI systems used in data analysis, education, and decision-making.
Student Responsibilities:
- Review literature on vision–language models, attention mechanisms, and chart understanding
- Curate or generate datasets for attention and robustness analysis
- Run experiments with existing multimodal large language models, analyzing attention patterns and reasoning processes
- Meet regularly with the supervisor for guidance, feedback, and research planning
The student will receive close mentorship, including regular meetings and hands-on support throughout the project.
Qualifications:
- Strong interest in machine learning, multimodal reasoning, or data visualization
- Familiarity with deep learning concepts, particularly LLMs and multimodal models
- Programming experience in Python
- Willingness to learn research tools and experimental methods
Work Setting:
- Combination of remote and On-site (UBC Vancouver Campus)
Project: Use OmniLink on All the Things
To apply, please contact the lead PhD student, Finn Hackett <fhackett@cs.ubc.ca>.
Project Outline:
Concurrent systems are hard to build. Different interleavings of events are hard to predict, and testing can easily miss interesting behaviors. We built OmniLink, an analysis tool that can cross-check whether a recorded multi-threaded program execution "makes sense" in relation to a TLA+ model of the intended behavior. We have had some success using our prototype, but we need to try it on a more diverse set of software. So, we need your help to try analyzing more open source projects (data structures, message queues, etc) with OmniLink. Every analysis is an opportunity to learn about a system in detail, and if OmniLink helps you find a bug, we'll help you send a Github Issue / Pull Request communicating (and maybe addressing) what you found.
For more details on our work so far, check out our preprint "Trace Validation of Unmodified Concurrent Systems with OmniLink", which should be on arxiv.org by the time you're reading this.
Student Responsibilities:
Build and use OmniLink validation setups for 1-2 (as many as possible really) systems, run those setups, and archive / triage results. You will be building / analyzing open source code we haven't seen before, so the ability to efficiently adapt to unfamiliar software artifacts is essential. You may also have to reverse engineer system models in TLA+, a modeling language you likely do not know yet. We will provide mentorship by the main author of OmniLink, learning materials, a remote development server, and pair programming as needed. You should also attend and present your progress at scheduled weekly meetings.
Qualifications:
- General purpose software engineering skills: version control, build systems, comfort with complex debugging scenarios, including multithreaded code.
- Ability to pick up Scala, TLA+, and the implementation languages of our target systems (TBD, might be C/C++, or other common programming languages).
- Interest in contributing to the open source community
Work Setting:
On-site (UBC Vancouver Campus), online possible
The following projects span computational mathematics, machine learning, and statistics. Each involves developing software implementations and testing on real-world data.
Project 1: Tensor Factorization with Automatic Differentiation
Background:
Tensor factorizations generalize low-rank matrix decomposition to higher-dimensional arrays. These techniques appear throughout scientific computing, statistics, and signal processing as tools for unsupervised learning and data compression.
Goal:
Extend our existing package BlockTensorFactorization.jl to support custom factorization models and objective functions beyond least-squares minimization.
Approach:
The project will use automatic differentiation (via Julia’s AD ecosystem) to enable flexible model specification. We will validate the new framework on both synthetic benchmarks and real-world datasets.
Prerequisites:
Linear algebra, multivariable calculus, and experience with a scientific programming language (Julia, Python, or MATLAB).
References:
• Richardson, Marusenko & Friedlander (2025). BlockTensorFactorization.jl
Project 2: Statistical Matrix Rank
Background:
The rank of a matrix measures the number of independent components in a dataset or linear transformation. While rank can theoretically be computed by counting nonzero singular values, noisy measurements and finite-precision arithmetic cause nearly every real-world matrix to appear full rank.
Goal:
Develop statistical methods to estimate the “true” rank of a matrix when noise follows a known distribution.
Approach:
We will leverage results from random matrix theory to characterize the distribution of singular values under noise. The project will produce a practical implementation tested on synthetic and real-world data
Prerequisites:
Linear algebra, probability/statistics, and experience with a scientific programming language (Julia, Python, or MATLAB).
Project 3: Moment Matching for Density Estimation
Background:
Recovering a probability density from observed moments (mean, variance, higher moments) is a classical problem in statistics and information theory. Maximum entropy methods select the “least presumptive” density consistent with the given constraints.
Goal:
Implement efficient numerical methods for maximum-entropy density estimation within the DualPerspective.jl package.
Approach:
The core computational challenge is evaluating integrals involving exponential-polynomial terms. This project will replace general-purpose adaptive quadrature with specialized Gauss quadrature rules (Gauss-Legendre, Gauss-Hermite) tailored to the problem structure, enabling fast gradient and Hessian computations for optimization
Prerequisites:
Linear algebra, numerical methods, and experience with Julia.
Project 1: Beyond Geometric Limits: Cognitive Breakdown in Haptic Retargeting
To apply, please contact the lead PhD student, Kaseya Xia <kaseya.xia@ubc.ca>.
Research Outline:
This research investigates hand redirection in VR as a perceptual phenomenon rather than a purely geometric one, focusing on how and why the illusion succeeds or fails. Hand redirection warps the virtual hand trajectory while the real hand touches a fixed physical surface, enabling haptic retargeting by reusing a single physical object for multiple virtual ones. While the technique is effective during task-focused interaction—where vision dominates haptics and small distortions go unnoticed—the work identifies a critical failure mechanism: users can switch from an interaction-oriented, sensorimotor perceptual mode to a reflective, metric judgment mode when prompted to reason about space (e.g., being asked to judge table size). This cognitive mode switch shifts attention to visuo-haptic conflict, activates prior knowledge, and causes the illusion to break. This research will provide design principles for robust VR and AR interfaces that align tasks with appropriate perceptual modes; it enables more reliable haptic retargeting for training, productivity, and spatial computing using minimal physical infrastructure; and it introduces a new cognitive failure mode for XR collaboration, where shared realities may fracture asymmetrically across users.
Student Responsibilities:
The student will work closely with a graduate researcher to explore and evaluate the perceptual phenomena described above. Responsibilities include:
- Assisting in the design and implementation of experimental systems (e.g., VR interaction prototypes)
- Helping to design and conduct user studies
- Participating in the full research workflow, including:
- Idea generation and conceptual development
- Experimental validation
- System implementation
- User testing and data collection
- Engaging in regular discussions and receive mentorship throughout the project
Qualifications
- Basic programming skills
- Familiarity with Unity and C#
- Interest in VR/XR, HCI, perception, or cognitive science
- Prior experience with HCI or psychology research is a plus, but not required
Work Setting:
- Due to the interactive and hardware-based nature of the project, the position requires in-person participation
- Work will be conducted in a lab setting with access to VR hardware and experimental equipment
- The student will collaborate closely with a graduate researcher throughout the project
Project 2: AI-powered Hyper-realistic AR/VR Telepresence
To apply, please contact the lead PhD student Xincheng Huang <xincheng.huang@ubc.ca> directly.
Research Outline:
The past few years have seen a rise in remote work and video conferencing, yet current 2D video tools lack the spatial and embodied richness of in-person interaction. This often leads to reduced engagement and “Zoom fatigue,” motivating interest in more immersive forms of remote collaboration.
Recent advances in AI-powered 3D reconstruction (e.g., Gaussian Splatting, NeRF) make it possible to experience remote environments with photo-realistic quality. In our prior work (GaussianNexus), we explored how combining 3D Gaussian Splatting with object tracking can enable dynamic, interactive telepresence.
In this project, we aim to explore how live visual input from wearable or mobile cameras can be used to incrementally update a high-quality 3D scene as a user moves through an environment. Students will work on components such as real-time rendering, camera-based scene updates, and visual representations of remote collaborators. Students can also participate in the system evaluation through user-centered comparative studies. The project offers opportunities to gain hands-on experience with computer vision/graphics, AR/VR, and human-centered interactive systems.
Student Responsibilities:
A student will work closely with a graduate researcher to:
- Assist the design and implementation of a research system prototype
- Participate in the design of system/user evaluation
Qualifications:
- Familiarity with any of the following: C, C++, Python, C#
- Basic understanding of Computer Vision/Graphics and/or Machine Learning
- Interest in Virtual and Augmented Reality
- Prior experience with Unity is a Plus, but NOT required
- Familiarity with Human-Centered design is a Plus, but NOT required
Work Setting:
- In-person participation is required throughout the course of the project
- Access to an XR workspace with AR/VR and computing hardware will be provided
Thomas Pasquier and Nguyen Phong Hoang
Project: Internet Privacy: Understanding Third Party Tracking
We are developing internet measurement methods to better understand third-party advertising and tracking on the web. A promising approach is to run instrumented browser crawls that visit real websites from different browsers and geographic vantage points, while recording network requests, redirects, cookies, and other behaviors. These measurements let us map which third parties are contacted and how tracking exposure changes with factors like location, browser settings, and consent prompts.
Responsibilities:
In this project, an undergraduate student will improve our existing measurement framework by integrating best practices from prior research. The student will read a small set of key papers, extract practical "do's and don'ts" (e.g., how to classify third parties, how to ensure repeatability, and how to log consent and page state), and then implement them in our crawler and analysis pipeline.
Qualifications:
This project draws on computer systems, security/privacy, and applied data analysis. The ideal student has strong programming skills and knowledge of the network stack (e.g., CPSC 317/417).
Work Setting:
On-site (UBC Vancouver Campus)