You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: content/gsoc_2026.md
+211-9Lines changed: 211 additions & 9 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -21,7 +21,28 @@ In your cover letter please include answers to the following questions:
21
21
Prospective contributors should read through the project ideas listed below before submitting an application, following the Contributor Guidance above.
22
22
Select a project based on your research interests and the technical experience you have, or would like to develop.
23
23
24
-
### Updating the Gambit GUI
24
+
For each project we have listed at least two possible mentors, with the first mentioned mentor like
25
+
to be the primary one and the other one able to act as a secondary additional mentor.
26
+
Our core team of mentors for 2026 are: [Ted Turocy](mailto:ted.turocy@gmail.com), [Rahul Savani](mailto:rahul.savani@gmail.com),
27
+
and [Ed Chalstrey](mailto:echalstrey@turing.ac.uk).
28
+
Bernhard von Stengel can act as an additional mentor for ideas 3 and 6; Bernhard authored the
29
+
`draw_tree` and `lemke` packages that underpin these two projects, respectively.
30
+
31
+
The following table summarises our ideas, and includes links to detailed descriptions below.
|[1](#idea-1-updating-the-gambit-gui)| Updating the Gambit GUI | Medium | GUI, visualization, C++, wxWidgets |
36
+
|[2](#idea-2-gameinterpreter-a-front-end-for-llm-based-game-translation)| GameInterpreter: A front-end for LLM-based game translation | Easy/Medium | LLMs, extensive-form games, front-end |
37
+
|[3](#idea-3-a-layout-algorithm-for-visualising-game-trees)| A layout algorithm for visualising game trees | Hard | Extensive-form games, visualization, graph drawing |
38
+
|[4](#idea-4-working-on-gambit-interoperability-with-sagemath)| Working on Gambit interoperability with SageMath | Easy/Medium | SageMath, interoperability, Python |
39
+
|[5](#idea-5-updating-how-gambit-works-with-external-solvers)| Development and integration of Lemke's algorithm package | Medium/Hard | Nash equilibrium, mathematical optimization; linear complementarity |
40
+
|[6](#idea-6-development-and-integration-of-lemkes-algorithm-package)| Updating how Gambit works with external solvers | Medium/Hard | Mathematical optimization; interoperability |
41
+
|[7](#idea-7-new-algorithms-for-finding-nash-equilibria)| New algorithms for finding Nash equilibria | Medium/Hard | Nash equilibrium, algorithms, mathematical optimization |
42
+
43
+
### Idea 1: "Updating the Gambit GUI"
44
+
45
+
#### Description
25
46
26
47
Gambit’s graphical interface is the oldest part of the package. It traces its origins to a MS-DOS based tool written in C++ using the Borland Graphics Interface (BGI) in the early 1990s. It was ported to wxWindows (now wxWidgets) in the mid-1990s, in the early days of that package. Growing emphasis on scriptability and calculation at scale has meant the GUI has received less attention in recent years. Nevertheless, it remains important to the package and the community as it is the point of entry for many users, either through use in teaching or in manually inputting small games for exploratory analysis.
27
48
@@ -31,18 +52,72 @@ In this project, we will modernise the implementation of the graphical interface
31
52
32
53
2. The interaction design of the canvas used to display game trees, and the tables used to display games in normal form, is less than ideal, with features like drag-and-drop, scrolling, and so forth being sometimes unreliable. These are due in part to legacy, in some cases dating back to the BGI implementation. We will clean up the dated parts of the interface to an application that gives a more modern appearance.
33
54
34
-
3. When the GUI was invented it was not possible to do meaningful analysis of games much larger than could be drawn by hand. Today Gambit supports the analysis of huge (by comparison) games. We will improve the scalability of the GUI to use the concepts we have developed for working with large games, including the ability to load and work with “standard” games from the extensive catalog of examples and benchmarks we have developed.
55
+
3. When the GUI was invented it was not possible to do meaningful analysis of games much larger than could be drawn by hand. Today Gambit supports the analysis of huge (by comparison) games. We will improve the scalability of the GUI to use the concepts we have developed for working with large games, including the ability to load and work with “standard” games from the extensive catalog of examples and benchmarks we have developed.
56
+
57
+
#### Expected outcomes
58
+
59
+
The key expected outcome of this project is a modernised version of the Gambit GUI.
60
+
61
+
#### Skills required/preferred
62
+
63
+
Experience with C++ is essential; experience with wxWidgets is desirable but not essential.
#### Expected size of project (90, 175, or 350 hours)
35
70
36
-
### GameInterpreter: A front-end for LLM-based game translation tools
71
+
We consider this a 350 hours project, especially if a student fully takes forward all 3 inter-related strands mentioned in the description. There is scope for a scaled down 175 hour project, but 90 hours does not appear enough to make enough progress to make this worthwhile.
72
+
73
+
#### Difficulty rating (easy/medium/hard)
74
+
75
+
Medium. Strands 1 and 2 should be relatively easy for someone with suitable C++ experience. The
76
+
3rd strand is more open-ended and challenging.
77
+
78
+
### Idea 2: "GameInterpreter: A front-end for LLM-based game translation"
79
+
80
+
#### Description
37
81
38
82
We have developed tools that leverage Large Language Models (LLMs) to translate natural language descriptions of games into formal game-theoretic models within Gambit. See, e.g.,
39
83
40
84
Shilong Deng, Yongzhao Wang, Rahul Savani:
41
85
*From Natural Language to Extensive-Form Game Representations*. **AAMAS 2025**: 593-601.
42
86
43
-
The method in that paper was called GameIntepreter v1; we are actively developing newer versions. In this project, a student would develop a front end that would allow users to explore the different versions of GameInterpreter.
87
+
The method in that paper was called GameInterpreter v1; we are actively developing newer versions. In this project, a student would develop a front end that would allow users to explore the different versions of GameInterpreter.
88
+
89
+
For a blog post describing the work above see: https://www.turing.ac.uk/blog/introducing-gambit-tool-doing-computation-game-theory.
90
+
91
+
A basic version of this project would provide a front end to allow users to run different translators
92
+
and compare and contrast the outputs.
93
+
An extended version would also incorporate our new methods for *automatically evaluating* the
94
+
correctness of translations.
95
+
96
+
#### Expected outcomes
97
+
98
+
The key expected outcome of this project is a browser-based front end that lets user
99
+
explore our tools that translate natural language descriptions of game to formal game-theoretic
100
+
models within Gambit.
101
+
102
+
#### Skills required/preferred
103
+
104
+
Experience with browser-based front-end development is essential.
#### Expected size of project (90, 175, or 350 hours)
111
+
112
+
90 hours for the basic version; 175 hours if the extension is done too.
113
+
114
+
#### Difficulty rating (easy/medium/hard)
115
+
116
+
Easy/Medium.
117
+
118
+
### Idea 3: "A layout algorithm for visualising game trees"
119
+
120
+
#### Description
46
121
47
122
Extensive form game trees differ from other kinds of trees in graph theory due to the presence of information sets, which make drawing such trees a unique challenge not addressed by other software packages. In Game Theory, in any game with “imperfect information”, where some players are not fully informed about the state of the world, information sets group decision nodes based on the information available to players.
48
123
@@ -52,11 +127,62 @@ The best current layout algorithm used in `draw_tree` is based on code originall
52
127
53
128
This project would suit someone who has a particular interest in visualisation challenges. For reference, check out the ["Stripped-down poker"](https://gambitproject.readthedocs.io/en/stable/tutorials/03_stripped_down_poker.html) tutorial from the `pygambit` documentation, which demonstrates how `pygambit` is used to construct, and `draw_tree` is used to visualise, a small extensive form game, including an explanation of the information sets present in the game.
54
129
55
-
### Working on Gambit interoperability with SageMath
130
+
#### Expected outcomes
131
+
132
+
The key expected outcome of this project is an implemented and tested new visualiztion algorithm for `draw_tree`.
133
+
134
+
#### Skills required/preferred
135
+
136
+
Experience with Python is essential; experience with "graph drawing" algorithms is desirable but not essential.
137
+
Keen interest in visualization and aesthetics is essential.
138
+
139
+
#### Possible mentors:
140
+
141
+
[Ed Chalstrey](mailto:echalstrey@turing.ac.uk); [Ted Turocy](mailto:ted.turocy@gmail.com). Bernhard von Stengel, who designed and authored the original `draw_tree`
142
+
implementation can act as an additional supporting mentor.
143
+
144
+
#### Expected size of project (90, 175, or 350 hours)
145
+
146
+
350 hours.
147
+
148
+
#### Difficulty rating (easy/medium/hard)
149
+
150
+
Hard. Developing a suitable layout algorithm that works across a wide range of games
151
+
and then implementing it and testing constitutes a significant project that we expect
152
+
to take up a full 350-hour project and to be challenging.
153
+
154
+
### Idea 4: "Working on Gambit interoperability with SageMath"
155
+
156
+
#### Description
56
157
57
158
SageMath is a prominent open source mathematical software system. SageMath has some existing support for Game Theory, including some interoperability with Gambit version 15. There is a desire on both the Gambit and SageMath sides to improve interoperability and to get SageMath working fully with Gambit version 16.5 and later – see the following PR: https://github.com/sagemath/sage/pull/37809. In this project, a student would work to update that PR with a view to getting it merged by SageMath. In addition, a student could develop tutorials to demonstrate existing and new interoperability between Gambit and SageMath (see the following issue from Gambit’s repo: [#627](https://github.com/gambitproject/gambit/issues/627).
58
159
59
-
### Updating how Gambit works with external solvers
160
+
#### Expected outcomes
161
+
162
+
The key expected outcome of this project is a merged SageMath pull request that would see the latest versions of Gambit integragted into SageMath. Ideally the integration will also be demonstrated with tutorials and docs.
163
+
164
+
#### Skills required/preferred
165
+
166
+
Experience with Python is essential; experience with SageMath is desirable but not essential.
#### Expected size of project (90, 175, or 350 hours)
173
+
174
+
90 or 175 hours. While it might be possible in 90 hours to implement the basic SageMath integration needed
175
+
to get a PR merged, we would have a strong preference for a student to also produce rich materials
176
+
(such as tutorials and examples) that show off the new integration, for which a 175 hour project
177
+
seems more reasonable.
178
+
179
+
#### Difficulty rating (easy/medium/hard)
180
+
181
+
Easy.
182
+
183
+
### Idea 5: "Updating how Gambit works with external solvers"
184
+
185
+
#### Description
60
186
61
187
Many mathematical problems that arise in game theory can be expressed in standard formulations. For example, there are many problems which can be expressed as linear programs, or the solutions to a system of polynomial equations and inequalities. Gambit has routines for solving these problems; for example, Gambit has an internal LP solver, in part because it was not straightforward to call or link with external packages circa 1994! In the modern scientific computing ecosystem, there are packages specialised to classes of mathematical programming or optimisation problems which will be far more performant.
62
188
@@ -66,8 +192,31 @@ In this project, we will develop a better framework for this process of generati
66
192
67
193
We are already aware from ad-hoc testing that in many cases the use of external solvers leads to huge performance gains, so success on this project would lead to a substantial increase in the size of game which is feasible to analyse.
68
194
195
+
#### Expected outcomes
196
+
197
+
The expected outcome of this project is an improved framework for working with external solvers
198
+
in Gambit. At a minimum requirement, the existing external solvers (e.g. lrc and PHCpack) should
199
+
use the new framework. As a stretch goal, an extended project could see several new external
200
+
solvers integrated with Gambit via the new framework.
201
+
202
+
#### Skills required/preferred
203
+
204
+
Experience with Python is essential; experience with mathematical optimization/programming is
205
+
highly desirable.
69
206
70
-
### Development and integration of Lemke's algorithm package
#### Expected size of project (90, 175, or 350 hours)
212
+
213
+
The core outcome of an improved framework for dealing with solvers could conceivably be done in 90 hours. Integration of new external solvers within the new framework could take the project to 175 hours, or even 350 depending on the number and complexity of the new external solvers.
214
+
215
+
#### Difficulty rating (easy/medium/hard)
216
+
217
+
Medium/Hard.
218
+
219
+
### Idea 6: "Development and integration of Lemke's algorithm package"
71
220
72
221
Lemke’s algorithm is an important method in mathematical optimization for solving “Linear Complementarity Problems” (LCPs). Two player games, either in extensive or strategic form, the two primary game formats in Gambit, can be cast as LCPs solved using Lemke’s algorithm and variants of it. While Gambit has an in-built implementation of Lemke’s algorithm in C++, we would like to integrate a python implementation of Lemke’s algorithm by Benrhard von Stengel.
73
222
@@ -77,7 +226,32 @@ The project would have two main parts:
77
226
78
227
2. Integrate the new “lemke” package with core Gambit (https://github.com/gambitproject/gambit/), as an optional dependency, and alternative to the in-built Lemke solver.
79
228
80
-
#### New algorithms for finding Nash equilibria
229
+
#### Expected outcomes
230
+
231
+
The key expected outcomes of this project are:
232
+
233
+
1. A modernised standalone "lemke" package;
234
+
2. Integration of the modernised package with Gambit.
235
+
236
+
#### Skills required/preferred
237
+
238
+
Experience with Python is essential; relevant background in complementary pivoting, or at least mathematical programming methods like the Simplex method (https://en.wikipedia.org/wiki/Simplex_algorithm) are highly desirable.
239
+
240
+
#### Possible mentors:
241
+
242
+
[Rahul Savani](mailto:rahul.savani@gmail.com); [Ted Turocy](mailto:ted.turocy@gmail.com); the author of the Lemke package (https://github.com/gambitproject/lemke), Bernhard von Stengel is also available to act as an part-time mentor on this project (in addition to having a primary and secondary mentor from the core Gambit team).
243
+
244
+
#### Expected size of project (90, 175, or 350 hours)
245
+
246
+
175 to 350 hours.
247
+
248
+
#### Difficulty rating (easy/medium/hard)
249
+
250
+
Medium/Hard.
251
+
252
+
### Idea 7: "New algorithms for finding Nash equilibria"
253
+
254
+
#### Description
81
255
82
256
There are several methods for computing Nash equilibrium which are based on numerical continuation, i.e. following a smooth (differentiable) path defined by a system of equations. Gambit has implementations of a few of these methods, but there are a number of others which have been published which Gambit does not yet include.
83
257
@@ -90,3 +264,31 @@ Two examples which are currently in Gambit’s issue list are:
90
264
While ultimately we would like to have C++ implementations of these methods, it would also be useful to create Python-based prototypes (using numpy for the numerical heavy lifting), which would aid in the production of test and benchmarking suites for these methods.
91
265
92
266
(There are many other methods for computing Nash equilibria and other solution concepts; we are interested in proposals to implement any of these within Gambit.)
267
+
268
+
#### Expected outcomes
269
+
270
+
The expected outcome of this project is implementations of one or more new equilibrium computiation methods, with these implementaitons integrated into Gambit.
271
+
272
+
#### Skills required/preferred
273
+
274
+
- As mentioned the implementations can be in either Python or C++, so experience in one or both of those is essential.
275
+
276
+
- Experience with the background in mathemetical optimization/programming behind equilibrium computation algorithms is highly desirable.
0 commit comments