GSoCIdeas: Difference between revisions

From GNU Radio
Jump to navigation Jump to search
(Add new paragraph for 2021)
 
(20 intermediate revisions by 9 users not shown)
Line 1: Line 1:
== Summer of Code 2021: Project ideas list ==
Note- also check out [[Grant Ideas]] for additional ideas that are more suited towards grant money than GSoC.


This is the list of project ideas for the summer of code 2021 within GNU Radio.<br />
Remember that these are '''ideas''' and are merely meant as an inspiration for you to write your own proposal.
Students who do not find a fit among these projects are encouraged to engage with us and suggest new ones. The [[MailingLists|GNU Radio discussion mailing list]] is the best place to contact all of us. Please do not contact us off-list for the sake of discussing the summer of code, unless you're contacting a mentor listed here to get feedback on a proposal.
Reviewing the [https://developers.google.com/open-source/gsoc/faq Google GSoC FAQ] page for a broader understanding of project, mentor, and student responsibilities is recommended.
If you need a USRP or other radio hardware to complete the project, we will be able to arrange something.
Please add ideas to this list (you may cannibalize old ideas, of course!).


Guidelines for good projects (when suggesting projects, please consider these):
== Summer of Code 2023: Project ideas list ==


* Clearly defined scope, with a main target that can be done in 3 months at 50% capacity
This is the list of project ideas for the summer of code 2023 within GNU Radio.<br />
* Clear benefits for the GNU Radio project
* Not specific to a certain hardware. No specific embedded devices, either, please.
* Both OOTs and in-tree improvements are welcome
 
'''The time a student can spend on a GSoC project has been reduced by 50% for 2021 - keep this in mind when submitting your ideas'''
 
 
== Summer of Code 2020: Project ideas list ==
 
This is the list of project ideas for the summer of code 2020 within GNU Radio.<br />
Remember that these are '''ideas''' and are merely meant as an inspiration for you to write your own proposal.
Remember that these are '''ideas''' and are merely meant as an inspiration for you to write your own proposal.


Line 41: Line 21:
* Not specific to a certain hardware. No specific embedded devices, either, please.
* Not specific to a certain hardware. No specific embedded devices, either, please.
* Both OOTs and in-tree improvements are welcome
* Both OOTs and in-tree improvements are welcome
=== GRC: Build-in sub flowgraphs ===
GNU Radio has the hierarchical blocks to build reuseable sub flowgraphs. These hier_blocks can be designed in GRC, however, they have to be compiled to code and GRC bindings, before they can be used in other GRC files. While this is great for reuseablity across flowgraphs, it is quite cumbersome when the main use is to structure a single (larger) flowgraph. The goal of this project is to ease this use-case by embedding sub flowgraphs directly in the main GRC file. Instead of creating bindings and code and then parsing them back again, this process shall be done in-place to allow quickly editing sub flowgraphs on-the-fly. 
'''Prerequisites'''
* GRC is written in Python which is (almost) all you need to know for this project.
'''Outcome'''
* A vastly improved workflow for structuring flowgraphs
'''Mentor(s)'''
* Sebastian Koslowski
=== Qt5 GUI Integrations ===
Idea: Wrap the Qt GUI sinks to appear in QtCreator, including the GUI aspects of their parameterization
'''Prerequisites'''
* C++, Python proficiency
* Qt experienced
'''Outcome'''
* Qt GUI Sinks usable as widgets in QtCreator (not necessarily already showing an "empty" GUI, just placeholders)
* Possible to import generate Qt GUI description file (UIC) into GRC
* Interface to map placeholders from GUI design to Qt GUI sinks in Flow graph
* Integration of that into GRC-generated Python code
'''Mentor(s)'''
* Marcus Müller & Sebastian "GRC-Man" Koslowski
=== GRC: View-Only Mode (Secure) ===
When a flowgraph from an untrusted source is opened if GRC, arbitrary Python code can be executed. This poses a potential security risk. Storing the all evaluated values of all parameters within a flow graph (.grc) file would allow us to open such flow graphs without compromising security. No code would be have to executed to draw the flow graph and block parameters can be viewed safely. Only if the flow graph is modified the user would have to choose to trust the flow graph thus enabling normal eval operations.
'''Prerequisites'''
* GRC is implemented using Python. So, Python should be known pretty well.
'''Outcome'''
* Safely view other people's flowgraphs without putting your PC at risk.
'''Mentor(s)'''
* Sebastian Koslowski
=== Extending and Updating gr-radar ===
gr-radar (https://github.com/kit-cel/gr-radar/) was a great and successful GSoC project that provided a few methods of radar in GNU Radio. This module is heavily used by academics, researchers, cybersecurity folks, and hobbyists. This project would work to improve upon the concepts already in there as well as add more radar techniques.
There are uncountable methods and techniques that could be added to this project, such as:
* SAR / InSAR methods
* Better passive radar support
* Speed camera applications
* Multi-antenna radar techniques
'''Prerequisites'''
* Signal processing and some radar basics are required.
* Code is written in C++ with some Python on the side, so the student must be able to handle these languages at the least.
'''Outcome'''
* Based on the student's interest, a subset of the radar techniques listed above (or others) are chosen as milestones for this project.
* All code must be merged back into gr-radar by the end of the summer.
'''Mentor(s)'''
* Stefan Wunsch, Martin Braun


=== QT Widgets Improvements ===
=== QT Widgets Improvements ===
Line 134: Line 27:
This project is cleanly divided into several sub-projects:
This project is cleanly divided into several sub-projects:


* Add new widgets
* Add a new widget
** Compass display (e.g. for direction-finding applications)
** Compass display (e.g. for direction-finding applications)
** MPEG display (e.g. for video demod output)
** MPEG display (e.g. for video demod output)
Line 152: Line 45:


* Familiarity with QT is essential.
* Familiarity with QT is essential.
* Widgets are written in C+'', so some C''+ knowledge is also required.
* Widgets are written in C++, so some C++ knowledge is also required.
* Python skills are highly useful.
* Python skills are highly useful.
'''Project length'''
350 hours
'''Difficulty'''
Hard


'''Mentor(s)'''
'''Mentor(s)'''


Tim O'Shea
Andrej Rode




=== GPU Accelerated Signal Processing Blocks ===


=== Standardized High Throughput FEC Codes ===
GPUs offer incredible capability for accelerating a number of signal processing routines when the calculations can be done in parallel.  Also, GNU Radio 3.10 brought in a "custom buffers" feature which provides support generally for accelerator devices by allowing blocks to have direct access to device memory, finally making accelerator processing feasible through a flowgraph (see [https://fosdem.org/2022/schedule/event/radio_gr3_10/ FOSDEM 2022 Presentation].


Channel coding is essential to modern communications. Also, it is computationally very heavy. As of now, there exist implementations in GNU Radio which are too slow to be integrated into high throughput applications. GNU Radio would benefit from integration of standardized decoders for Turbo and LDPC codes. These codes would only support a certain subset of the whole code class but would be well optimized.  
One piece that is missing for GNU Radio is a library of blocks that accelerate common DSP routines.  There are several interesting libraries of GPU accelerated signal processing - primarily using CUDA because of its accessible programming paradigm and the ubiquity of NVIDIA hardware:
 
* [https://github.com/NVIDIA/MatX Matx]
* [https://github.com/rapidsai/cusignal cuSignal] (Python signal processing)
* [https://github.com/gnuradio/cusp CUSP]
 
Integration of any of this functionality, along with additional kernels for signal processing would need to be predicated on using [https://github.com/gnuradio/gr-cuda gr-cuda] custom buffers, and expanding this module as needed
 
This project can be broken into several subprojects:
 
* Create gr-matx OOT
** Add Matx Custom Buffer Type (after gr-cuda)
** Create blocks wrapping Matx operations
* Expand gr-cuda
** Additional custom buffer types - pinned, unified
** Create python custom buffers allowing zero copy into python blocks
* Create gr-cuSignal
** Wrap cuSignal functionality (dependent on python zero copy)
* Replicate existing GR blocks as CUDA accelerated (things not in cuSignal or Matx)
** Target for extensions to Matx, cuSignal, or CUSP (within our control)
** FIR Filters
** Polyphase Resampler
** Signal Source
** Moving Average
** Polyphase Clock Sync
** Stream Operators
** ...


'''Prerequisites'''
'''Prerequisites'''


* Understanding of ''gr-fec'' API. Knowledge on channel coding. Understanding of C++.
* Knowledge of C++ and Python.
* Familiarity with CUDA programming


'''Outcome'''
'''Project length'''
 
350 hours
 
'''Difficulty'''


* Standardized Codes, e.g. LTE Turbo Codes, 5G Polar Codes, 5G LDPC Codes, CCITT Convolutional Codes etc. are available in ''gr-fec''.
Medium
* The preferred goal is to find a highly optimized implementation and integrate these into GNU Radio.


'''Mentor(s)'''
'''Mentor(s)'''


* Johannes Demel
Josh Morman




=== GRC: Standalone application and pluggable workflows ===


=== Android ===
GNU Radio Companion (GRC) has become useful outside of just GNU Radio, and several projects have forked and maintained their own versions.  Even within GRC, there are different workflows (QT GUI, C++, Bokeh-gui) with different options in the path to render a working flowgraph see [https://github.com/gnuradio/greps/blob/main/grep-0025-grc-out-of-tree.md GREP 0025].  In its most basic form, GRC does the following:


One effort of the past years was to improve Android support for GNU Radio. We're getting to a point where we've figured out '''how''' to do it, so the next step is to make it more accessible to users and developers.
* User sets high level options (type of flowgraph)
* User draws flowgraph graphically with blocks and connections
* Flowgraph uses templates (Mako) to render to a python script


The Android ecosystem is an entirely different beast from the rest of GNU Radio. To make writing Android/GR apps easy, the following needs to happen (and shall be part of this project):
The goal of this project is to pull GRC out of the GNU Radio codebase and make the workflow modular.  There should be a high level selection of the workflow that defines the options block.  In our current usage these workflows could be:


* Improve support for development environment
* Python QT GUI
** Create Dockers for easy start of development
* C++ QT GUI
* Visualization classes for PSD, spectrogram and oscilloscope
* Python No GUI
** Easy reuse in other apps, like the gr-qtgui widgets, but for Android SDKs
* C++ No GUI
* Interactivity concepts
* Bokeh GUI
** Gestures and config for radio parameters (e.g., freq, gain, bandwidth)
** Create an example FM receiver app that allows easy channel selection etc. through motions and gestures


You can find a summary of the work that has been done on this (years ago) here: [[Android]]
The workflow should map to a set of templates that are used to render the output script.  The definition of the workflow options and the associated templates should be defined in some pluggable manner (files dropped into a directory that GRC sees at runtime), so that "out of tree" workflows can be added easily - because we don't know all the use cases of GRC.
 
'''Steps'''
* Move GRC as a separate repository (while maintaining git history)
* Remove dependence of GRC on gnuradio
* Modularized options block
* Modularized templates
* Allow templating with jinja as well
* If time allows:
** Modularize gr-modtool templates as well per [https://github.com/gnuradio/greps/blob/main/grep-0026-modtool-template-rework.md GREP 0026]
** Support multiple domains' workflows.


'''Prerequisites'''
'''Prerequisites'''


* Some Android experience
* Knowledge of Python.
* Enjoy writing GUI widgets
* C++/Java experience


'''Mentor(s)'''
'''Project length'''


* Bastian Bloessl
350 hours


=== Runtime Benchmarks ===
'''Difficulty'''


To facilitate development of a more modern GNU Radio runtime and scheduler, we need a tool to measure its performance (in terms of delay and throughput).
Medium
This data is required to compare alternate approaches and to become aware of performance regressions early in the process.


The goal of the project is to provide a tool to benchmark the GNU Radio runtime. Since we are interested in the performance on many platforms and architectures, it should provide an option to submit performance data to our sever, allowing us to crowdsource data. (Similar to our [http://stats.gnuradio.org/ online stats] for SIMD performance.)
'''Mentor(s)'''


* Come up with interesting metrics and, if needed, implement blocks to extract them.
Josh Morman,
* Come up with interesting flowgraph topologies that should be benchmarked.
Håkon Vågsether,
* Setup automated experiments that iterate over a given parameter space (repetitions, number of samples, size of the flowgraph).
Sebastian Koslowski,
* Parse, evaluate, and visualize the data.
?? Someone else that is a GRC Wizard
* Add an option to upload the performance data to our web sever.


'''Prerequisites'''
=== GRC: Build-in sub flowgraphs ===


* C++ programming
GNU Radio has hierarchical blocks as a way to build reuseable sub flowgraphs. These hier_blocks can be designed in GRC, however, they have to be compiled to code and GRC bindings, before they can be used in other GRC files. While this is great for reuseablity across flowgraphs, it is quite cumbersome when the main use is to structure a single (larger) flowgraph. The goal of this project is to ease this use-case by embedding sub flowgraphs directly in the main GRC file. Instead of creating bindings and code and then parsing them back again, this process shall be done in-place to allow quickly editing sub flowgraphs on-the-fly. 
* Data evaluation and visualization
* Automation tools (like GNU Make to run benchmarks)


'''Mentor(s)'''
'''Prerequisites'''


* Bastian Bloessl, Marcus Mueller
* GRC is written in Python which is (almost) all you need to know for this project.


=== Filter Design Tool Enhancements ===
'''Outcome'''


GNU Radio provides many tools to design and use digital filters. Using these tools requires both some expertise in these areas as well as an understanding of the performance on the given platform. One example is the selection between FIR (convolution-based) and FFT (fast convolution-based) filters for different resampling rates. Another example is doing stages of filter decomposition when doing large down-sampling. Included in this is the polyphase filterbanks, which again are provided as primitive blocks that need tweaking to work.
* A vastly improved workflow for structuring flowgraphs


This project is to improve our uses of these tools and blocks to make it more obvious to the users as well as automate some of the decisions for optimally using them. Some pointers:
'''Project length'''


* When used in GRC, we want to save the results of the tool in a local file or for use in actual blocks.
175 hours
* It still currently runs on PyQWT, which is obsolete and needs to be updated to Qt5
** See https://github.com/trondeau/gnuradio/tree/filter/design_tool_newgui
* Add more support for filter design concepts and other filters.
** Cascaded filters
** Better support for creating PFB filters


'''Prerequisites'''
'''Difficulty'''


* Strong DSP background required.
Easy
* Python and QT knowledge highly useful (at least one of those is a must).


'''Mentor(s)'''
'''Mentor(s)'''


* Marcus Leech
Håkon Vågsether




=== Revitalize old modules ===


=== Implement SigMF functionality for the GNU Radio Ecosystem ===
Some of the in-tree modules are in need of attention. For example, gr-wavelet does not have any examples, and several of the tests in gr-trellis are failing.


SigMF is the "Signal Metadata Format" that was defined during the 2017 DARPA Hackfest in Brussels. Its purpose is to annotate raw binary dumps of signals with metadata, thus giving meaning to a raw mass of samples.<br />
'''Prerequisites'''
SigMF is specified and has a minimal reference implementation here: https://github.com/gnuradio/sigmf
There is an out-of-tree module providing SigMF functionality for GNU Radio as well: https://github.com/skysafe/gr-sigmf


However, SigMF is not represented well in the GNU Radio tooling landscape. Therefore, a subset of tools can be extended by SigMF support. Incomplete lists of possible tools benefitting from SigMF support:
* Knowledge of C++, Python and DSP.


* qgrx (https://github.com/csete/gqrx)
'''Outcome'''
* inspectrum (https://github.com/miek/inspectrum)
* ...


Any additional tools are welcome in a proposal.
* More example code, tests and flowgraphs for various in-tree modules


'''Prerequisites'''
'''Project length'''


* Knowledge of the programming language of the covered tools.
175 hours
* Hands-on experience with the respective tools.
* Familiarity with the SigMF specification.


'''Outcome'''
'''Difficulty'''


* The tools worked on have capability to load and save files in the SigMF format.
Easy
* Depending on the specific tool, SigMF meta data is displayed within the tool.
* The number of tools worked on needs to be determined by the student, depending on his/her experience.


'''Mentor(s)'''
'''Mentor(s)'''


* Sebastian Müller, Andrej Rode
Håkon Vågsether, ?




=== CI for maintenance branches and select OOT modules ===


=== Statistical Toolbox for GRC ===
It would be useful to have nightly builds for GNU Radio's maintenance branches (3.8, 3.9, 3.10) and some select OOTs.  
 
A statistical toolbox for GRC would enable GUI-based statistical analysis. Currently, such analysis can be done by writing an independent program (e.g., with SciPy), but there is no actual integration with GNU Radio. By developing the statistical toolbox, we provide blocks for probability distribution fitting, hypothesis testing, extracting statistical parameters for one-dimensional as well as multi-dimensional data. This would significantly expand GNU Radio users' ability to perform data-science analysis and modeling on signal data.


'''Prerequisites'''
'''Prerequisites'''


* Understanding of existing GNU Radio tools (e.g., GRC), GNU Radio Out-of-Tree Modules, and statistics / data-science modeling.
* Experience with Docker?
* ?


'''Outcome'''
'''Outcome'''


* An OOT module that provides statistical analysis capabilities for GNU Radio.
* Automated PPAs, Snaps, Flatpak apps
 
'''Project length'''
 
175 hours
 
'''Difficulty'''
 
Easy


'''Mentor(s)'''
'''Mentor(s)'''


* Ben Hilburn
Håkon Vågsether, ?


== Application process ==
== Old Ideas ==


Students interested in participating, read the [[GSoCStudentInfo|student instructions]] and the [[GSoCManifest|rules of conduct]].
Feel free to browse [https://wiki.gnuradio.org/index.php?title=OldGSoCIdeas old ideas] from previous years for inspiration.
* Please introduce yourself on the [https://lists.gnu.org/mailman/listinfo/discuss-gnuradio GNU Radio mailing list]
* Fill in the formal application for GNU Radio
* Pick some items from the list above or feel free to suggest another piece of work relevant to this theme. Give us a detailed, week-by-week plan for completing the task over the summer.

Latest revision as of 19:21, 7 February 2023

Note- also check out Grant Ideas for additional ideas that are more suited towards grant money than GSoC.


Summer of Code 2023: Project ideas list

This is the list of project ideas for the summer of code 2023 within GNU Radio.
Remember that these are ideas and are merely meant as an inspiration for you to write your own proposal.

Students who do not find a fit among these projects are encouraged to engage with us and suggest new ones. The GNU Radio discussion mailing list is the best place to contact all of us. Please do not contact us off-list for the sake of discussing the summer of code, unless you're contacting a mentor listed here to get feedback on a proposal.

Reviewing the Google GSoC FAQ page for a broader understanding of project, mentor, and student responsibilities is recommended.

If you need a USRP or other radio hardware to complete the project, we will be able to arrange something.

Please add ideas to this list (you may cannibalize old ideas, of course!).

Guidelines for good projects (when suggesting projects, please consider these):

  • Clearly defined scope, with a main target that can be done in 3 months
  • Clear benefits for the GNU Radio project
  • Not specific to a certain hardware. No specific embedded devices, either, please.
  • Both OOTs and in-tree improvements are welcome

QT Widgets Improvements

The gr-qtgui in-tree component provides some QT widgets for signal visualization. This component needs some improvement to become more useful.
This project is cleanly divided into several sub-projects:

  • Add a new widget
    • Compass display (e.g. for direction-finding applications)
    • MPEG display (e.g. for video demod output)
    • Matrix sink (e.g. for radar Doppler/range plane visualization, or 2D-equalizer taps visualization)
  • Improve current widgets
    • Better code structure to make the current widgets more manageable, extensible and remove code duplication between widgets
    • More Control Panels on other widgets (follow lead on the frequency sink)
    • Improve UI, make more intuitive, more power to mouse users
    • Set trigger point with mouse
  • Integration / Support for QT Creator
    • QML design
    • Allow to build full GUI applications from, say, GRC

Prerequisites

  • Familiarity with QT is essential.
  • Widgets are written in C++, so some C++ knowledge is also required.
  • Python skills are highly useful.

Project length

350 hours

Difficulty

Hard

Mentor(s)

Andrej Rode


GPU Accelerated Signal Processing Blocks

GPUs offer incredible capability for accelerating a number of signal processing routines when the calculations can be done in parallel. Also, GNU Radio 3.10 brought in a "custom buffers" feature which provides support generally for accelerator devices by allowing blocks to have direct access to device memory, finally making accelerator processing feasible through a flowgraph (see FOSDEM 2022 Presentation.

One piece that is missing for GNU Radio is a library of blocks that accelerate common DSP routines. There are several interesting libraries of GPU accelerated signal processing - primarily using CUDA because of its accessible programming paradigm and the ubiquity of NVIDIA hardware:

Integration of any of this functionality, along with additional kernels for signal processing would need to be predicated on using gr-cuda custom buffers, and expanding this module as needed

This project can be broken into several subprojects:

  • Create gr-matx OOT
    • Add Matx Custom Buffer Type (after gr-cuda)
    • Create blocks wrapping Matx operations
  • Expand gr-cuda
    • Additional custom buffer types - pinned, unified
    • Create python custom buffers allowing zero copy into python blocks
  • Create gr-cuSignal
    • Wrap cuSignal functionality (dependent on python zero copy)
  • Replicate existing GR blocks as CUDA accelerated (things not in cuSignal or Matx)
    • Target for extensions to Matx, cuSignal, or CUSP (within our control)
    • FIR Filters
    • Polyphase Resampler
    • Signal Source
    • Moving Average
    • Polyphase Clock Sync
    • Stream Operators
    • ...

Prerequisites

  • Knowledge of C++ and Python.
  • Familiarity with CUDA programming

Project length

350 hours

Difficulty

Medium

Mentor(s)

Josh Morman


GRC: Standalone application and pluggable workflows

GNU Radio Companion (GRC) has become useful outside of just GNU Radio, and several projects have forked and maintained their own versions. Even within GRC, there are different workflows (QT GUI, C++, Bokeh-gui) with different options in the path to render a working flowgraph see GREP 0025. In its most basic form, GRC does the following:

  • User sets high level options (type of flowgraph)
  • User draws flowgraph graphically with blocks and connections
  • Flowgraph uses templates (Mako) to render to a python script

The goal of this project is to pull GRC out of the GNU Radio codebase and make the workflow modular. There should be a high level selection of the workflow that defines the options block. In our current usage these workflows could be:

  • Python QT GUI
  • C++ QT GUI
  • Python No GUI
  • C++ No GUI
  • Bokeh GUI

The workflow should map to a set of templates that are used to render the output script. The definition of the workflow options and the associated templates should be defined in some pluggable manner (files dropped into a directory that GRC sees at runtime), so that "out of tree" workflows can be added easily - because we don't know all the use cases of GRC.

Steps

  • Move GRC as a separate repository (while maintaining git history)
  • Remove dependence of GRC on gnuradio
  • Modularized options block
  • Modularized templates
  • Allow templating with jinja as well
  • If time allows:
    • Modularize gr-modtool templates as well per GREP 0026
    • Support multiple domains' workflows.

Prerequisites

  • Knowledge of Python.

Project length

350 hours

Difficulty

Medium

Mentor(s)

Josh Morman, Håkon Vågsether, Sebastian Koslowski, ?? Someone else that is a GRC Wizard

GRC: Build-in sub flowgraphs

GNU Radio has hierarchical blocks as a way to build reuseable sub flowgraphs. These hier_blocks can be designed in GRC, however, they have to be compiled to code and GRC bindings, before they can be used in other GRC files. While this is great for reuseablity across flowgraphs, it is quite cumbersome when the main use is to structure a single (larger) flowgraph. The goal of this project is to ease this use-case by embedding sub flowgraphs directly in the main GRC file. Instead of creating bindings and code and then parsing them back again, this process shall be done in-place to allow quickly editing sub flowgraphs on-the-fly.

Prerequisites

  • GRC is written in Python which is (almost) all you need to know for this project.

Outcome

  • A vastly improved workflow for structuring flowgraphs

Project length

175 hours

Difficulty

Easy

Mentor(s)

Håkon Vågsether


Revitalize old modules

Some of the in-tree modules are in need of attention. For example, gr-wavelet does not have any examples, and several of the tests in gr-trellis are failing.

Prerequisites

  • Knowledge of C++, Python and DSP.

Outcome

  • More example code, tests and flowgraphs for various in-tree modules

Project length

175 hours

Difficulty

Easy

Mentor(s)

Håkon Vågsether, ?


CI for maintenance branches and select OOT modules

It would be useful to have nightly builds for GNU Radio's maintenance branches (3.8, 3.9, 3.10) and some select OOTs.

Prerequisites

  • Experience with Docker?
  • ?

Outcome

  • Automated PPAs, Snaps, Flatpak apps

Project length

175 hours

Difficulty

Easy

Mentor(s)

Håkon Vågsether, ?

Old Ideas

Feel free to browse old ideas from previous years for inspiration.

Retrieved from "https://wiki.gnuradio.org/index.php?title=GSoCIdeas&oldid=12939"