Grew is a Graph Rewriting tool dedicated to applications in NLP. Some of the major features of the Grew software:

  • Graph structures can use a build-in notion of feature structures.
  • The left-hand side of a rule is described by a graph called a pattern; injective graph morphisms are used in the pattern matching algorithm.
  • Negative pattern can be used for a finer control on the left-hand side of rules.
  • The right-hand side of rules is described by a sequence of atomic commands that describe how the graph should be modified during the rule application.
  • Subset of rules are grouped in modules; the full rewriting process being a sequence of module applications.
  • The Grew software has support both for confluent and non-confluent modules; when a non-confluent modules is used, all normal forms are returned and then ambiguity is handled in a natural way.

Grew can be used through several running modes:

  • a Graphical User Interface which can show all intermediate graphs used during the rewriting process (useful either to debug rewriting system of for demonstrations);
  • a Corpus mode produces various statistics about rules usage and HTML pages with final results of the rewriting process;
  • a Deterministic mode where Grew is graph transformation tools that can be used in a larger pipeline;

Online Usage

There are two online interface for Grew:

  • Grew-web is an online version of Grew where you can search patterns in corpora.
  • Grew-demo is an online interface giving for a input French sentence a list of linguistic analysis: surface dependency syntax, deep dependency syntax, DMRS.




Syntax for Graphs

Syntax for GRS files

Available Graph Rewrite Systems


The parsing GRS (see IWPT 2015) is available:

svn co svn://

It takes as input the POS-tagged representation of a sentence and returns a surface dependency syntax tree following the FTB/Sequoia format. The input can be produced for instance by MElt with the command:

echo "Ceci est une phrase de test." | MElt -L -T > test.melt

Then, the parsing is done with the command:

grew -det -grs parsing/rewriting_rules/main.grs -seq full -i test.melt -f

and produce the following output:

1	Ceci	ceci	PRO	PRO	det=y|sentid=00000	2	suj	_	_
2	est	être	V	V	m=ind	_	_	_	_
3	une	un	D	DET	_	4	det	_	_
4	phrase	phrase	N	NC	det=y|s=c	2	ats	_	_
5	de	de	P	P	type=deloc	4	dep	_	_
6	test	test	N	NC	s=c	5	obj.p	_	_
7	.	.	PONCT	PONCT	_	2	ponct	_	_

Deep syntax

The deep syntax reprensentation is built in two successive steps:

  • a compact mixed representation of surface and deep dependencies (used in the corpus Deep-sequoia) is produced:
svn co svn://
grew -det -grs deep_syntax/grs/deep_syntax.grs -i -f test.mix.conll
  • a projection of the mixed representation to the deep representation:
svn co svn://
grew -det -grs tools/proj.grs -seq deep -i test.mix.conll -f test.deep.conll


The GRS producting the DMRS semantic representation can be downloaded and executed by the following commands:

svn co svn://
grew -det -grs DMRS/rewriting_rules/dmrs.grs -i test.deep.conll -f test.dmrs.conll

Obsolete system

SynSem_FTB is the first GRS built in 2012; it was used to compute DMRS semantic representation from dependency surface syntactic relations. This system is not maintained and is now replaced by other GRS presented above.



People involved

The rewriting tool is developed in the Sémagramme Team (LORIA - INRIA).

  • Bruno GUILLAUME is the main developer of the Grew system.
  • Guy PERRIER is the main developer on the Graph Rewriting Systems.
  • Guillaume BONFANTE wrote the first prototype and is always around to discuss formal aspects.
  • Mathieu MOREY were involved in the birth of the ideas used in Grew.
  • Paul MASSON built the Gtk interface and make everything easier to install and use.