<section>
  <h4><%= loc 'recentCorpusPub' %></h4>

  <p class="bibentry">Kupietz, Marc/Leinen, Peter/Diewald, Nils/Genêt, Philippe/Wilm, Rebecca/Witt, Andreas/Yaddehige, Rameela (2025): <cite><a class="extern"  href="https://doi.org/10.5281/zenodo.14943116">National Library as Corpus: Introducing DeLiKo@DNB – a Large Synchronous German Fiction Corpus</a>. in Book of Abstracts. DHd 2025 Under Construction (DHd2025), Bielefeld, S. 482--485.
<span class='Z3988' title='url_ver=Z39.88-2004&amp;ctx_ver=Z39.88-2004&amp;rfr_id=info%3Asid%2Fzotero.org%3A2&amp;rft_id=info%3Adoi%2Fhttps%3A%2F%2Fdoi.org%2F10.5281%2Fzenodo.14887460&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=proceeding&amp;rft.atitle=National%20Library%20as%20Corpus%3A%20Introducing%20DeLiKo%40DNB%20%E2%80%93%20a%20Large%20Synchronous%20German%20Fiction%20Corpus&amp;rft.btitle=Book%20of%20Abstracts&amp;rft.place=Bielefeld&amp;rft.aufirst=Marc&amp;rft.aulast=Kupietz&amp;rft.au=Marc%20Kupietz&amp;rft.au=Peter%20Leinen&amp;rft.au=Nils%20Diewald&amp;rft.au=Philippe%20Gen%C3%AAt&amp;rft.au=Rebecca%20Wilm&amp;rft.au=Andreas%20Witt&amp;rft.au=Rameela%20Yaddehige&amp;rft.date=2025-02-26&amp;rft.pages=482--485&amp;rft.spage=482'></span></p>

  
</section>

<section>
  <h4><%= loc 'recentToolPub' %></h4>

  <p class="bibentry">Diewald, Nils/Bodmer, Franck/Harders, Peter/Irimia, Elena/Kupietz, Marc/Margaretha, Eliza/Stallkamp, Helge (2021): <cite><a class="extern" href="https://nbn-resolving.org/urn:nbn:de:bsz:mh39-103342">KorAP und EuReCo – Recherchieren in mehrsprachigen vergleichbaren Korpora</a></cite><br />In: Lobin, Henning/Witt, Andreas/Wöllstein, Angelika (Hrsg.): Deutsch in Europa. Sprachpolitisch, grammatisch, methodisch. Jahrbuch des Instituts für Deutsche Sprache 2020. (= Jahrbuch des Instituts für Deutsche Sprache 2020). Berlin/Boston: de Gruyter, 287-294.
    <span class='Z3988' title='url_ver=Z39.88-2004&amp;ctx_ver=Z39.88-2004&amp;rfr_id=info%3Asid%2Fzotero.org%3A2&amp;rft_id=urn%3Aisbn%3A978-3-11-073519-2&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=bookitem&amp;rft.atitle=KorAP%20und%20EuReCo%20%E2%80%93%20Recherchieren%20in%20mehrsprachigen%20vergleichbaren%20Korpora&amp;rft.btitle=Deutsch%20in%20Europa.%20Sprachpolitisch%2C%20grammatisch%2C%20methodisch.&amp;rft.place=Berlin%20%5Bu.a.%5D&amp;rft.publisher=de%20Gruyter&amp;rft.series=Jahrbuch%20%2F%20Leibniz-Institut%20f%C3%BCr%20Deutsche%20Sprache%20(IDS)%20-%202020%20-&amp;rft.aufirst=Nils&amp;rft.aulast=Diewald&amp;rft.au=Nils%20Diewald&amp;rft.au=Franck%20Bodmer&amp;rft.au=Peter%20Harders&amp;rft.au=Elena%20Irimia&amp;rft.au=Marc%20Kupietz&amp;rft.au=Eliza%20Margaretha&amp;rft.au=Helge%20Stallkamp&amp;rft.au=Henning%20Lobin&amp;rft.au=Andreas%20Witt&amp;rft.au=Angelika%20W%C3%B6llstein&amp;rft.date=2021&amp;rft.pages=287-293&amp;rft.spage=287&amp;rft.epage=293&amp;rft.isbn=978-3-11-073519-2'></span>
  </p>

  <p class="bibentry">Kupietz, Marc/Diewald, Nils/Margaretha, Eliza/Bodmer, Franck/Stallkamp, Helge/Harders, Peter (2020): <cite><a href="https://nbn-resolving.org/urn:nbn:de:bsz:mh39-97052">Recherche in Social-Media-Korpora mit KorAP</a></cite><br />In: Marx, Konstanze/Lobin, Henning/Schmidt, Axel (Hrsg.), Deutsch in Sozialen Medien. Interaktiv, multimodal, vielfältig, Jahrbuch des Instituts für Deutsche Sprache 2019. de Gruyter, Berlin/Boston, pp. 373–378.
    <span class='Z3988' title='url_ver=Z39.88-2004&amp;ctx_ver=Z39.88-2004&amp;rfr_id=info%3Asid%2Fzotero.org%3A2&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=proceeding&amp;rft.atitle=Recherche%20in%20Social-Media-Korpora%20mit%20KorAP&amp;rft.btitle=Deutsch%20in%20Sozialen%20Medien.%20Interaktiv%2C%20multimodal%2C%20vielf%C3%A4ltig&amp;rft.place=Berlin%2FBoston&amp;rft.publisher=de%20Gruyter&amp;rft.series=Jahrbuch%20des%20Instituts%20f%C3%BCr%20Deutsche%20Sprache%202019&amp;rft.aufirst=Marc&amp;rft.aulast=Kupietz&amp;rft.au=Marc%20Kupietz&amp;rft.au=Nils%20Diewald&amp;rft.au=Eliza%20Margaretha&amp;rft.au=Franck%20Bodmer&amp;rft.au=Helge%20Stallkamp&amp;rft.au=Peter%20Harders&amp;rft.date=2020&amp;rft.pages=373-378&amp;rft.spage=373&amp;rft.epage=378'></span>
  </p>

  <p class="bibentry">Diewald, Nils/Hanl, Michael/Margaretha, Eliza/Bingel, Joachim/Kupietz, Marc/Bański, Piotr/Witt, Andreas (2016): <cite><a href="https://nbn-resolving.org/urn:nbn:de:bsz:mh39-50361">KorAP architecture - Diving in the Deep Sea of Corpus Data</a></cite><br />In: Proceedings of the 10th International Conference on Language Resources and Evaluation (LREC 2016). Portorož/Paris: European Language Resources Association (ELRA), pp. 3586–3591.
    <span class='Z3988' title='url_ver=Z39.88-2004&amp;ctx_ver=Z39.88-2004&amp;rfr_id=info%3Asid%2Fzotero.org%3A2&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=proceeding&amp;rft.atitle=KorAP%20architecture%20-%20Diving%20in%20the%20Deep%20Sea%20of%20Corpus%20Data&amp;rft.btitle=Proceedings%20of%20the%20Tenth%20International%20Conference%20on%20Language%20Resources%20and%20Evaluation%20(LREC%202016)&amp;rft.place=Portoro%C5%BE%2C%20Slovenia&amp;rft.aufirst=Nils&amp;rft.aulast=Diewald&amp;rft.au=Nils%20Diewald&amp;rft.au=Michael%20Hanl&amp;rft.au=Eliza%20Margaretha&amp;rft.au=Joachim%20Bingel&amp;rft.au=Marc%20Kupietz&amp;rft.au=Piotr%20Ba%C5%84ski&amp;rft.au=Andreas%20Witt&amp;rft.date=2016&amp;rft.pages=3586-3591&amp;rft.spage=3586&amp;rft.epage=3591'></span>
  </p>
</section>
